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

Changeset - 29e29db5e6b4

Parent rev.

Child rev.

[Not reviewed]

0 9 0

MH - 3 years ago 2022-02-24 11:45:19
contact@maxhenger.nl

WIP: Remove unique id inside definition, replace with type index

9 files changed with 316 insertions and 253 deletions:

src/protocol/ast.rs

104

src/protocol/ast_printer.rs

src/protocol/eval/executor.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_rewriting.rs

src/protocol/parser/pass_typing.rs

138

124

src/protocol/parser/pass_validation_linking.rs

src/protocol/parser/type_table.rs

src/protocol/tests/utils.rs

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -927,221 +927,262 @@ pub struct StructFieldDefinition { @@
     pub parser_type: ParserType,
+}
 #[derive(Debug, Clone)]
 pub struct StructDefinition {
     pub this: StructDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parsing
     pub fields: Vec<StructFieldDefinition>
+}
 impl StructDefinition {
     pub(crate) fn new_empty(
         this: StructDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, span, identifier, poly_vars, fields: Vec::new() }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum EnumVariantValue {
     None,
     Integer(i64),
+}
 #[derive(Debug, Clone)]
 pub struct EnumVariantDefinition {
     pub identifier: Identifier,
     pub value: EnumVariantValue,
+}
 #[derive(Debug, Clone)]
 pub struct EnumDefinition {
     pub this: EnumDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parsing
     pub variants: Vec<EnumVariantDefinition>,
+}
 impl EnumDefinition {
     pub(crate) fn new_empty(
         this: EnumDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, span, identifier, poly_vars, variants: Vec::new() }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct UnionVariantDefinition {
     pub span: InputSpan,
     pub identifier: Identifier,
     pub value: Vec<ParserType>, // if empty, then union variant does not contain any embedded types
+}
 #[derive(Debug, Clone)]
 pub struct UnionDefinition {
     pub this: UnionDefinitionId,
     pub defined_in: RootId,
     // Phase 1: symbol scanning
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Phase 2: parsing
     pub variants: Vec<UnionVariantDefinition>,
+}
 impl UnionDefinition {
     pub(crate) fn new_empty(
         this: UnionDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, span, identifier, poly_vars, variants: Vec::new() }
+    }
+}
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ProcedureKind {
     Function, // with return type
     Primitive, // without return type
     Composite,
+}
 /// Monomorphed instantiation of a procedure (or the sole instantiation of a
 /// non-polymorphic procedure).
 pub struct ProcedureDefinitionMonomorph {
     pub argument_types: Vec<TypeId>,
-    pub expr_info: Vec<MonomorphExpressionInfo>
+    pub expr_info: Vec<ExpressionInfo>
+}
 pub struct MonomorphExpressionInfo {
 impl ProcedureDefinitionMonomorph {
     pub(crate) fn new_invalid() -> Self {
         return Self{
             argument_types: Vec::new(),
             expr_info: Vec::new(),
+        }
+    }
+}
 pub struct ExpressionInfo {
     pub type_id: TypeId,
     pub index: i32, // for called procedure's monomorphs, or selected field indices
     pub variant: ExpressionInfoVariant,
+}
 impl ExpressionInfo {
     pub(crate) fn new_invalid() -> Self {
         return Self{
             type_id: TypeId::new_invalid(),
             variant: ExpressionInfoVariant::Generic,
+        }
+    }
+}
 #[derive(Clone, Copy)]
 pub enum ExpressionInfoVariant {
     Generic,
     Procedure(TypeId, u32), // procedure TypeID and its monomorph index
     Select(i32), // index
+}
 impl ExpressionInfoVariant {
     pub(crate) fn as_select(&self) -> i32 {
         match self {
             ExpressionInfoVariant::Select(v) => *v,
             _ => unreachable!(),
+        }
+    }
     pub(crate) fn as_procedure(&self) -> (TypeId, u32) {
         match self {
             ExpressionInfoVariant::Procedure(type_id, monomorph_index) => (*type_id, *monomorph_index),
             _ => unreachable!(),
+        }
+    }
+}
 /// Generic storage for functions, primitive components and composite
 /// components.
 // Note that we will have function definitions for builtin functions as well. In
 // that case the span, the identifier span and the body are all invalid.
 #[derive(Debug, Clone)]
 pub struct ProcedureDefinition {
     pub this: ProcedureDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub builtin: bool,
     pub kind: ProcedureKind,
     pub span: InputSpan,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parser
     pub return_type: Option<ParserType>, // present on functions, not components
     pub parameters: Vec<VariableId>,
     pub scope: ScopeId,
     pub body: BlockStatementId,
     // Monomorphization of typed procedures
-    pub monomorphs: Vec<ProcedureMonomorph>,
+    pub monomorphs: Vec<ProcedureDefinitionMonomorph>,
     // Validation/linking
     pub num_expressions_in_body: i32,
+}
 impl ProcedureDefinition {
     pub(crate) fn new_empty(
         this: ProcedureDefinitionId, defined_in: RootId, span: InputSpan,
         kind: ProcedureKind, identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self {
             this, defined_in,
             builtin: false,
             span,
             kind, identifier, poly_vars,
             return_type: None,
             parameters: Vec::new(),
             scope: ScopeId::new_invalid(),
             body: BlockStatementId::new_invalid(),
             monomorphs: Vec::new(),
             num_expressions_in_body: -1,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub enum Statement {
     Block(BlockStatement),
     EndBlock(EndBlockStatement),
     Local(LocalStatement),
     Labeled(LabeledStatement),
     If(IfStatement),
     EndIf(EndIfStatement),
     While(WhileStatement),
     EndWhile(EndWhileStatement),
     Break(BreakStatement),
     Continue(ContinueStatement),
     Synchronous(SynchronousStatement),
     EndSynchronous(EndSynchronousStatement),
     Fork(ForkStatement),
     EndFork(EndForkStatement),
     Select(SelectStatement),
     EndSelect(EndSelectStatement),
     Return(ReturnStatement),
     Goto(GotoStatement),
     New(NewStatement),
     Expression(ExpressionStatement),
+}
 impl Statement {
     pub fn as_new(&self) -> &NewStatement {
         match self {
             Statement::New(result) => result,
             _ => panic!("Unable to cast `Statement` to `NewStatement`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             Statement::Block(v) => v.span,
             Statement::Local(v) => v.span(),
             Statement::Labeled(v) => v.label.span,
             Statement::If(v) => v.span,
             Statement::While(v) => v.span,
             Statement::Break(v) => v.span,
             Statement::Continue(v) => v.span,
             Statement::Synchronous(v) => v.span,
             Statement::Fork(v) => v.span,
             Statement::Select(v) => v.span,
             Statement::Return(v) => v.span,
             Statement::Goto(v) => v.span,
             Statement::New(v) => v.span,
             Statement::Expression(v) => v.span,
             Statement::EndBlock(_)
             | Statement::EndIf(_)
             | Statement::EndWhile(_)
             | Statement::EndSynchronous(_)
             | Statement::EndFork(_)
             | Statement::EndSelect(_) => unreachable!(),
+        }
+    }
     pub fn link_next(&mut self, next: StatementId) {
         match self {
             Statement::Block(stmt) => stmt.next = next,
             Statement::EndBlock(stmt) => stmt.next = next,
             Statement::Local(stmt) => match stmt {
                 LocalStatement::Channel(stmt) => stmt.next = next,
                 LocalStatement::Memory(stmt) => stmt.next = next,
             },
             Statement::EndIf(stmt) => stmt.next = next,
             Statement::EndWhile(stmt) => stmt.next = next,
             Statement::EndSynchronous(stmt) => stmt.next = next,
             Statement::EndFork(stmt) => stmt.next = next,
             Statement::EndSelect(stmt) => stmt.next = next,
             Statement::New(stmt) => stmt.next = next,
             Statement::Expression(stmt) => stmt.next = next,
             Statement::Return(_)
@@ @@ -1444,447 +1485,476 @@ pub enum Expression { @@
     Slicing(SlicingExpression),
     Select(SelectExpression),
     Literal(LiteralExpression),
     Cast(CastExpression),
     Call(CallExpression),
     Variable(VariableExpression),
+}
 impl Expression {
     pub fn as_variable(&self) -> &VariableExpression {
         match self {
             Expression::Variable(result) => result,
             _ => panic!("Unable to cast `Expression` to `VariableExpression`"),
+        }
+    }
     /// Returns operator span, function name, a binding's "let" span, etc. An
     /// indicator for the kind of expression that is being applied.
     pub fn operation_span(&self) -> InputSpan {
         match self {
             Expression::Assignment(expr) => expr.operator_span,
             Expression::Binding(expr) => expr.operator_span,
             Expression::Conditional(expr) => expr.operator_span,
             Expression::Binary(expr) => expr.operator_span,
             Expression::Unary(expr) => expr.operator_span,
             Expression::Indexing(expr) => expr.operator_span,
             Expression::Slicing(expr) => expr.slicing_span,
             Expression::Select(expr) => expr.operator_span,
             Expression::Literal(expr) => expr.span,
             Expression::Cast(expr) => expr.cast_span,
             Expression::Call(expr) => expr.func_span,
             Expression::Variable(expr) => expr.identifier.span,
+        }
+    }
     /// Returns the span covering the entire expression (i.e. including the
     /// spans of the arguments as well).
     pub fn full_span(&self) -> InputSpan {
         match self {
             Expression::Assignment(expr) => expr.full_span,
             Expression::Binding(expr) => expr.full_span,
             Expression::Conditional(expr) => expr.full_span,
             Expression::Binary(expr) => expr.full_span,
             Expression::Unary(expr) => expr.full_span,
             Expression::Indexing(expr) => expr.full_span,
             Expression::Slicing(expr) => expr.full_span,
             Expression::Select(expr) => expr.full_span,
             Expression::Literal(expr) => expr.span,
             Expression::Cast(expr) => expr.full_span,
             Expression::Call(expr) => expr.full_span,
             Expression::Variable(expr) => expr.identifier.span,
+        }
+    }
     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,
+        }
+    }
     pub fn parent_mut(&mut self) -> &mut ExpressionParent {
         match self {
             Expression::Assignment(expr) => &mut expr.parent,
             Expression::Binding(expr) => &mut expr.parent,
             Expression::Conditional(expr) => &mut expr.parent,
             Expression::Binary(expr) => &mut expr.parent,
             Expression::Unary(expr) => &mut expr.parent,
             Expression::Indexing(expr) => &mut expr.parent,
             Expression::Slicing(expr) => &mut expr.parent,
             Expression::Select(expr) => &mut expr.parent,
             Expression::Literal(expr) => &mut expr.parent,
             Expression::Cast(expr) => &mut expr.parent,
             Expression::Call(expr) => &mut expr.parent,
             Expression::Variable(expr) => &mut expr.parent,
+        }
+    }
     pub fn parent_expr_id(&self) -> Option<ExpressionId> {
         if let ExpressionParent::Expression(id, _) = self.parent() {
             Some(*id)
         } else {
             None
+        }
+    }
     pub fn get_unique_id_in_definition(&self) -> i32 {
     pub fn type_index(&self) -> i32 {
         match self {
             Expression::Assignment(expr) => expr.type_index,
             Expression::Binding(expr) => expr.type_index,
             Expression::Conditional(expr) => expr.type_index,
             Expression::Binary(expr) => expr.type_index,
             Expression::Unary(expr) => expr.type_index,
             Expression::Indexing(expr) => expr.type_index,
             Expression::Slicing(expr) => expr.type_index,
             Expression::Select(expr) => expr.type_index,
             Expression::Literal(expr) => expr.type_index,
             Expression::Cast(expr) => expr.type_index,
             Expression::Call(expr) => expr.type_index,
             Expression::Variable(expr) => expr.type_index,
+        }
+    }
     pub fn type_index_mut(&mut self) -> &mut 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,
             Expression::Assignment(expr) => &mut expr.type_index,
             Expression::Binding(expr) => &mut expr.type_index,
             Expression::Conditional(expr) => &mut expr.type_index,
             Expression::Binary(expr) => &mut expr.type_index,
             Expression::Unary(expr) => &mut expr.type_index,
             Expression::Indexing(expr) => &mut expr.type_index,
             Expression::Slicing(expr) => &mut expr.type_index,
             Expression::Select(expr) => &mut expr.type_index,
             Expression::Literal(expr) => &mut expr.type_index,
             Expression::Cast(expr) => &mut expr.type_index,
             Expression::Call(expr) => &mut expr.type_index,
             Expression::Variable(expr) => &mut expr.type_index,
+        }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum AssignmentOperator {
     Set,
     Concatenated,
     Multiplied,
     Divided,
     Remained,
     Added,
     Subtracted,
     ShiftedLeft,
     ShiftedRight,
     BitwiseAnded,
     BitwiseXored,
     BitwiseOred,
+}
 #[derive(Debug, Clone)]
 pub struct AssignmentExpression {
     pub this: AssignmentExpressionId,
     // Parsing
     pub operator_span: InputSpan,
     pub full_span: InputSpan,
     pub left: ExpressionId,
     pub operation: AssignmentOperator,
     pub right: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct BindingExpression {
     pub this: BindingExpressionId,
     // Parsing
     pub operator_span: InputSpan,
     pub full_span: InputSpan,
     pub bound_to: ExpressionId,
     pub bound_from: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct ConditionalExpression {
     pub this: ConditionalExpressionId,
     // Parsing
     pub operator_span: InputSpan,
     pub full_span: InputSpan,
     pub test: ExpressionId,
     pub true_expression: ExpressionId,
     pub false_expression: ExpressionId,
     // Validator/Linking
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: 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 operator_span: InputSpan,
     pub full_span: InputSpan,
     pub left: ExpressionId,
     pub operation: BinaryOperator,
     pub right: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: 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 operator_span: InputSpan,
     pub full_span: InputSpan,
     pub operation: UnaryOperator,
     pub expression: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct IndexingExpression {
     pub this: IndexingExpressionId,
     // Parsing
     pub operator_span: InputSpan,
     pub full_span: InputSpan,
     pub subject: ExpressionId,
     pub index: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct SlicingExpression {
     pub this: SlicingExpressionId,
     // Parsing
     pub slicing_span: InputSpan, // from '[' to ']'
     pub full_span: InputSpan, // includes subject
     pub subject: ExpressionId,
     pub from_index: ExpressionId,
     pub to_index: ExpressionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub enum SelectKind {
     StructField(Identifier),
     TupleMember(u64), // u64 is overkill, but space is taken up by `StructField` variant anyway
+}
 #[derive(Debug, Clone)]
 pub struct SelectExpression {
     pub this: SelectExpressionId,
     // Parsing
     pub operator_span: InputSpan, // of the '.'
     pub full_span: InputSpan, // includes subject and field
     pub subject: ExpressionId,
     pub kind: SelectKind,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct CastExpression {
     pub this: CastExpressionId,
     // Parsing
     pub cast_span: InputSpan, // of the "cast" keyword,
     pub full_span: InputSpan, // includes the cast subject
     pub to_type: ParserType,
     pub subject: ExpressionId,
     // Validator/linker
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: i32,
+}
 #[derive(Debug, Clone)]
 pub struct CallExpression {
     pub this: CallExpressionId,
     // Parsing
     pub func_span: InputSpan, // of the function name
     pub full_span: InputSpan, // includes the arguments and parentheses
     pub parser_type: ParserType, // of the function call, not the return type
     pub method: Method,
     pub arguments: Vec<ExpressionId>,
     pub procedure: ProcedureDefinitionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: i32,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Method {
     // Builtin, accessible by programmer
     Get,
     Put,
     Fires,
     Create,
     Length,
     Assert,
     Print,
     // Builtin, not accessible by programmer
     SelectStart, // SelectStart(total_num_cases, total_num_ports)
     SelectRegisterCasePort, // SelectRegisterCasePort(case_index, port_index, port_id)
     SelectWait, // SelectWait() -> u32
     // User-defined
-    UserProcedure,
+    UserFunction,
     UserComponent,
+}
 #[derive(Debug, Clone)]
 pub struct MethodSymbolic {
     pub(crate) parser_type: ParserType,
     pub(crate) definition: DefinitionId
 impl Method {
     pub(crate) fn is_public_builtin(&self) -> bool {
         use Method::*;
         match self {
             Get | Put | Fires | Create | Length | Assert | Print => true,
             _ => false,
+        }
+    }
     pub(crate) fn is_user_defined(&self) -> bool {
         use Method::*;
         match self {
             UserFunction | UserComponent => true,
             _ => false,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct LiteralExpression {
     pub this: LiteralExpressionId,
     // Parsing
     pub span: InputSpan,
     pub value: Literal,
     // Validator/Linker
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: 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>),
     Tuple(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)
+        }
+    }
     pub(crate) fn as_enum(&self) -> &LiteralEnum {
         if let Literal::Enum(literal) = self {
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Enum", self)
+        }
+    }
     pub(crate) fn as_union(&self) -> &LiteralUnion {
         if let Literal::Union(literal) = self {
             literal
         } else {
             unreachable!("Attempted to obtain {:?} as Literal::Union", self)
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct LiteralInteger {
     pub(crate) unsigned_value: u64,
     pub(crate) negated: bool, // for constant expression evaluation, TODO: @Int
+}
 #[derive(Debug, Clone)]
 pub struct LiteralStructField {
     // Phase 1: parser
     pub(crate) identifier: Identifier,
     pub(crate) value: ExpressionId,
     // Phase 2: linker
     pub(crate) field_idx: usize, // in struct definition
+}
 #[derive(Debug, Clone)]
 pub struct LiteralStruct {
     // Phase 1: parser
     pub(crate) parser_type: ParserType,
     pub(crate) fields: Vec<LiteralStructField>,
     pub(crate) definition: DefinitionId,
+}
 #[derive(Debug, Clone)]
 pub struct LiteralEnum {
     // Phase 1: parser
     pub(crate) parser_type: ParserType,
     pub(crate) variant: Identifier,
     pub(crate) definition: DefinitionId,
     // Phase 2: linker
     pub(crate) variant_idx: usize, // as present in the type table
+}
 #[derive(Debug, Clone)]
 pub struct LiteralUnion {
     // Phase 1: parser
     pub(crate) parser_type: ParserType,
     pub(crate) variant: Identifier,
     pub(crate) values: Vec<ExpressionId>,
     pub(crate) definition: DefinitionId,
     // Phase 2: linker
     pub(crate) variant_idx: usize, // as present in type table
+}
 #[derive(Debug, Clone)]
 pub struct VariableExpression {
     pub this: VariableExpressionId,
     // Parsing
     pub identifier: Identifier,
     // Validator/Linker
     pub declaration: Option<VariableId>,
     pub used_as_binding_target: bool,
     pub parent: ExpressionParent,
     // Typing
-    pub expr_index: i32,
+    pub type_index: i32,
+}
@@ \ No newline at end of file @@

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -481,405 +481,405 @@ impl ASTWriter { @@
                     .with_opt_identifier_val(stmt.label.as_ref());
                 self.kv(indent2).with_s_key("Target")
                     .with_disp_val(&stmt.target.0.index);
             },
             Statement::Synchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_SYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("Synchronous");
                 self.kv(indent2).with_s_key("EndSync").with_disp_val(&stmt.end_sync.0.index);
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, stmt.body, indent3);
             },
             Statement::EndSynchronous(stmt) => {
                 self.kv(indent).with_id(PREFIX_ENDSYNC_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndSynchronous");
                 self.kv(indent2).with_s_key("StartSync").with_disp_val(&stmt.start_sync.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Fork(stmt) => {
                 self.kv(indent).with_id(PREFIX_FORK_STMT_ID, stmt.this.0.index)
                     .with_s_key("Fork");
                 self.kv(indent2).with_s_key("EndFork").with_disp_val(&stmt.end_fork.0.index);
                 self.kv(indent2).with_s_key("LeftBody");
                 self.write_stmt(heap, stmt.left_body, indent3);
                 if let Some(right_body_id) = stmt.right_body {
                     self.kv(indent2).with_s_key("RightBody");
                     self.write_stmt(heap, right_body_id, indent3);
+                }
             },
             Statement::EndFork(stmt) => {
                 self.kv(indent).with_id(PREFIX_END_FORK_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndFork");
                 self.kv(indent2).with_s_key("StartFork").with_disp_val(&stmt.start_fork.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Select(stmt) => {
                 self.kv(indent).with_id(PREFIX_SELECT_STMT_ID, stmt.this.0.index)
                     .with_s_key("Select");
                 self.kv(indent2).with_s_key("EndSelect").with_disp_val(&stmt.end_select.0.index);
                 self.kv(indent2).with_s_key("Cases");
                 let indent3 = indent2 + 1;
                 let indent4 = indent3 + 1;
                 for case in &stmt.cases {
                     self.kv(indent3).with_s_key("Guard");
                     self.write_stmt(heap, case.guard, indent4);
                     self.kv(indent3).with_s_key("Block");
                     self.write_stmt(heap, case.body, indent4);
+                }
             },
             Statement::EndSelect(stmt) => {
                 self.kv(indent).with_id(PREFIX_END_SELECT_STMT_ID, stmt.this.0.index)
                     .with_s_key("EndSelect");
                 self.kv(indent2).with_s_key("StartSelect").with_disp_val(&stmt.start_select.0.index);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
+            }
             Statement::Return(stmt) => {
                 self.kv(indent).with_id(PREFIX_RETURN_STMT_ID, stmt.this.0.index)
                     .with_s_key("Return");
                 self.kv(indent2).with_s_key("Expressions");
                 for expr_id in &stmt.expressions {
                     self.write_expr(heap, *expr_id, indent3);
+                }
             },
             Statement::Goto(stmt) => {
                 self.kv(indent).with_id(PREFIX_GOTO_STMT_ID, stmt.this.0.index)
                     .with_s_key("Goto");
                 self.kv(indent2).with_s_key("Label").with_identifier_val(&stmt.label);
                 self.kv(indent2).with_s_key("Target")
                     .with_disp_val(&stmt.target.0.index);
             },
             Statement::New(stmt) => {
                 self.kv(indent).with_id(PREFIX_NEW_STMT_ID, stmt.this.0.index)
                     .with_s_key("New");
                 self.kv(indent2).with_s_key("Expression");
                 self.write_expr(heap, stmt.expression.upcast(), indent3);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
             },
             Statement::Expression(stmt) => {
                 self.kv(indent).with_id(PREFIX_EXPR_STMT_ID, stmt.this.0.index)
                     .with_s_key("ExpressionStatement");
                 self.write_expr(heap, stmt.expression, indent2);
                 self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);
+            }
+        }
+    }
     fn write_expr(&mut self, heap: &Heap, expr_id: ExpressionId, indent: usize) {
         let expr = &heap[expr_id];
         let indent2 = indent + 1;
         let indent3 = indent2 + 1;
         match expr {
             Expression::Assignment(expr) => {
                 self.kv(indent).with_id(PREFIX_ASSIGNMENT_EXPR_ID, expr.this.0.index)
                     .with_s_key("AssignmentExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Binding(expr) => {
                 self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("BindingExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("BindToExpression");
                 self.write_expr(heap, expr.bound_to, indent3);
                 self.kv(indent2).with_s_key("BindFromExpression");
                 self.write_expr(heap, expr.bound_from, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Conditional(expr) => {
                 self.kv(indent).with_id(PREFIX_CONDITIONAL_EXPR_ID, expr.this.0.index)
                     .with_s_key("ConditionalExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Condition");
                 self.write_expr(heap, expr.test, indent3);
                 self.kv(indent2).with_s_key("TrueExpression");
                 self.write_expr(heap, expr.true_expression, indent3);
                 self.kv(indent2).with_s_key("FalseExpression");
                 self.write_expr(heap, expr.false_expression, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Binary(expr) => {
                 self.kv(indent).with_id(PREFIX_BINARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("BinaryExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Left");
                 self.write_expr(heap, expr.left, indent3);
                 self.kv(indent2).with_s_key("Right");
                 self.write_expr(heap, expr.right, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Unary(expr) => {
                 self.kv(indent).with_id(PREFIX_UNARY_EXPR_ID, expr.this.0.index)
                     .with_s_key("UnaryExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Operation").with_debug_val(&expr.operation);
                 self.kv(indent2).with_s_key("Argument");
                 self.write_expr(heap, expr.expression, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Indexing(expr) => {
                 self.kv(indent).with_id(PREFIX_INDEXING_EXPR_ID, expr.this.0.index)
                     .with_s_key("IndexingExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Index");
                 self.write_expr(heap, expr.index, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Slicing(expr) => {
                 self.kv(indent).with_id(PREFIX_SLICING_EXPR_ID, expr.this.0.index)
                     .with_s_key("SlicingExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("FromIndex");
                 self.write_expr(heap, expr.from_index, indent3);
                 self.kv(indent2).with_s_key("ToIndex");
                 self.write_expr(heap, expr.to_index, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Select(expr) => {
                 self.kv(indent).with_id(PREFIX_SELECT_EXPR_ID, expr.this.0.index)
                     .with_s_key("SelectExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 match &expr.kind {
                     SelectKind::StructField(field_name) => {
                         self.kv(indent2).with_s_key("StructField").with_identifier_val(field_name);
                     },
                     SelectKind::TupleMember(member_index) => {
                         self.kv(indent2).with_s_key("TupleMember").with_disp_val(member_index);
                     },
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Literal(expr) => {
                 self.kv(indent).with_id(PREFIX_LITERAL_EXPR_ID, expr.this.0.index)
                     .with_s_key("LiteralExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 let val = self.kv(indent2).with_s_key("Value");
                 match &expr.value {
                     Literal::Null => { val.with_s_val("null"); },
                     Literal::True => { val.with_s_val("true"); },
                     Literal::False => { val.with_s_val("false"); },
                     Literal::Character(data) => { val.with_disp_val(data); },
                     Literal::String(data) => {
                         // Stupid hack
                         let string = String::from(data.as_str());
                         val.with_disp_val(&string);
                     },
                     Literal::Integer(data) => { val.with_debug_val(data); },
                     Literal::Struct(data) => {
                         val.with_s_val("Struct");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         for field in &data.fields {
                             self.kv(indent3).with_s_key("Field");
                             self.kv(indent4).with_s_key("Name").with_identifier_val(&field.identifier);
                             self.kv(indent4).with_s_key("Index").with_disp_val(&field.field_idx);
                             self.kv(indent4).with_s_key("ParserType");
                             self.write_expr(heap, field.value, indent4 + 1);
+                        }
                     },
                     Literal::Enum(data) => {
                         val.with_s_val("Enum");
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                     },
                     Literal::Union(data) => {
                         val.with_s_val("Union");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("ParserType")
                             .with_custom_val(|t| write_parser_type(t, heap, &data.parser_type));
                         self.kv(indent3).with_s_key("Definition").with_disp_val(&data.definition.index);
                         self.kv(indent3).with_s_key("VariantIdx").with_disp_val(&data.variant_idx);
                         for value in &data.values {
                             self.kv(indent3).with_s_key("Value");
                             self.write_expr(heap, *value, indent4);
+                        }
                     },
                     Literal::Array(data) => {
                         val.with_s_val("Array");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("Elements");
                         for expr_id in data {
                             self.write_expr(heap, *expr_id, indent4);
+                        }
                     },
                     Literal::Tuple(data) => {
                         val.with_s_val("Tuple");
                         let indent4 = indent3 + 1;
                         self.kv(indent3).with_s_key("Elements");
                         for expr_id in data {
                             self.write_expr(heap, *expr_id, indent4);
+                        }
+                    }
+                }
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Cast(expr) => {
                 self.kv(indent).with_id(PREFIX_CAST_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("ToType")
                     .with_custom_val(|t| write_parser_type(t, heap, &expr.to_type));
                 self.kv(indent2).with_s_key("Subject");
                 self.write_expr(heap, expr.subject, indent3);
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
+            }
             Expression::Call(expr) => {
                 self.kv(indent).with_id(PREFIX_CALL_EXPR_ID, expr.this.0.index)
                     .with_s_key("CallExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 let definition = &heap[expr.procedure];
                 self.kv(indent2).with_s_key("BuiltIn").with_disp_val(&false);
                 self.kv(indent2).with_s_key("Variant").with_debug_val(&definition.kind);
                 self.kv(indent2).with_s_key("MethodName").with_identifier_val(&definition.identifier);
                 self.kv(indent2).with_s_key("ParserType")
                     .with_custom_val(|t| write_parser_type(t, heap, &expr.parser_type));
                 // Arguments
                 self.kv(indent2).with_s_key("Arguments");
                 for arg_id in &expr.arguments {
                     self.write_expr(heap, *arg_id, indent3);
+                }
                 // Parent
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
             },
             Expression::Variable(expr) => {
                 self.kv(indent).with_id(PREFIX_VARIABLE_EXPR_ID, expr.this.0.index)
                     .with_s_key("VariableExpr");
-                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);
+                self.kv(indent2).with_s_key("TypeIndex").with_disp_val(&expr.type_index);
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&expr.identifier);
                 self.kv(indent2).with_s_key("Definition")
                     .with_opt_disp_val(expr.declaration.as_ref().map(|v| &v.index));
                 self.kv(indent2).with_s_key("Parent")
                     .with_custom_val(|v| write_expression_parent(v, &expr.parent));
+            }
+        }
+    }
     fn write_variable(&mut self, heap: &Heap, variable_id: VariableId, indent: usize) {
         let var = &heap[variable_id];
         let indent2 = indent + 1;
         self.kv(indent).with_id(PREFIX_VARIABLE_ID, variable_id.index)
             .with_s_key("Variable");
         self.kv(indent2).with_s_key("Name").with_identifier_val(&var.identifier);
         self.kv(indent2).with_s_key("Kind").with_debug_val(&var.kind);
         self.kv(indent2).with_s_key("ParserType")
             .with_custom_val(|w| write_parser_type(w, heap, &var.parser_type));
         self.kv(indent2).with_s_key("RelativePos").with_disp_val(&var.relative_pos_in_parent);
         self.kv(indent2).with_s_key("UniqueScopeID").with_disp_val(&var.unique_id_in_scope);
+    }
     //--------------------------------------------------------------------------
     // Printing Utilities
     //--------------------------------------------------------------------------
     fn kv(&mut self, indent: usize) -> KV {
         KV::new(&mut self.buffer, &mut self.temp1, &mut self.temp2, indent)
+    }
     fn flush<W: IOWrite>(&mut self, w: &mut W) {
         w.write(self.buffer.as_bytes()).unwrap();
         self.buffer.clear()
+    }
+}
 fn write_option<V: Display>(target: &mut String, value: Option<V>) {
     target.clear();
     match &value {
         Some(v) => target.push_str(&format!("Some({})", v)),
         None => target.push_str("None")
     };
+}
 fn write_parser_type(target: &mut String, heap: &Heap, t: &ParserType) {
     use ParserTypeVariant as PTV;
     fn write_element(target: &mut String, heap: &Heap, t: &ParserType, mut element_idx: usize) -> usize {
         let element = &t.elements[element_idx];
         match &element.variant {
             PTV::Void => target.push_str("void"),
             PTV::InputOrOutput => {
                 target.push_str("portlike<");
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push('>');
             },
             PTV::ArrayLike => {
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push_str("[???]");
             },
             PTV::IntegerLike => target.push_str("integerlike"),
             PTV::Message => { target.push_str(KW_TYPE_MESSAGE_STR); },
             PTV::Bool => { target.push_str(KW_TYPE_BOOL_STR); },
             PTV::UInt8 => { target.push_str(KW_TYPE_UINT8_STR); },
             PTV::UInt16 => { target.push_str(KW_TYPE_UINT16_STR); },
             PTV::UInt32 => { target.push_str(KW_TYPE_UINT32_STR); },
             PTV::UInt64 => { target.push_str(KW_TYPE_UINT64_STR); },
             PTV::SInt8 => { target.push_str(KW_TYPE_SINT8_STR); },
             PTV::SInt16 => { target.push_str(KW_TYPE_SINT16_STR); },
             PTV::SInt32 => { target.push_str(KW_TYPE_SINT32_STR); },
             PTV::SInt64 => { target.push_str(KW_TYPE_SINT64_STR); },
             PTV::Character => { target.push_str(KW_TYPE_CHAR_STR); },
             PTV::String => { target.push_str(KW_TYPE_STRING_STR); },
             PTV::IntegerLiteral => { target.push_str("int_literal"); },
             PTV::Inferred => { target.push_str(KW_TYPE_INFERRED_STR); },
             PTV::Array => {
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push_str("[]");
             },
             PTV::Input => {
                 target.push_str(KW_TYPE_IN_PORT_STR);
                 target.push('<');
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push('>');
             },
             PTV::Output => {
                 target.push_str(KW_TYPE_OUT_PORT_STR);
                 target.push('<');
                 element_idx = write_element(target, heap, t, element_idx + 1);
                 target.push('>');
             },
             PTV::Tuple(num_embedded) => {
                 target.push('(');
                 let num_embedded = *num_embedded;

src/protocol/eval/executor.rs

➞

Show inline comments

 use std::collections::VecDeque;
 use super::value::*;
 use super::store::*;
 use super::error::*;
 use crate::protocol::*;
 use crate::protocol::ast::*;
 use crate::protocol::type_table::*;
 macro_rules! debug_enabled { () => { false }; }
 macro_rules! debug_log {
     ($format:literal) => {
         enabled_debug_print!(false, "exec", $format);
     };
     ($format:literal, $($args:expr),*) => {
         enabled_debug_print!(false, "exec", $format, $($args),*);
     };
+}
 #[derive(Debug, Clone)]
 pub(crate) enum ExprInstruction {
     EvalExpr(ExpressionId),
     PushValToFront,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct Frame {
     pub(crate) definition: ProcedureDefinitionId,
     pub(crate) monomorph_type_id: TypeId,
     pub(crate) monomorph_index: usize,
     pub(crate) position: StatementId,
     pub(crate) expr_stack: VecDeque<ExprInstruction>, // hack for expression evaluation, evaluated by popping from back
     pub(crate) expr_values: VecDeque<Value>, // hack for expression results, evaluated by popping from front/back
     pub(crate) max_stack_size: u32,
+}
 impl Frame {
     /// Creates a new execution frame. Does not modify the stack in any way.
     pub fn new(heap: &Heap, definition_id: ProcedureDefinitionId, monomorph_type_id: TypeId) -> Self {
         let definition = &heap[definition_id];
         let outer_scope_id = definition.scope;
         let first_statement_id = definition.body;
         // Another not-so-pretty thing that has to be replaced somewhere in the
         // future...
         fn determine_max_stack_size(heap: &Heap, scope_id: ScopeId, max_size: &mut u32) {
             let scope = &heap[scope_id];
             // Check current block
             let cur_size = scope.next_unique_id_in_scope as u32;
             if cur_size > *max_size { *max_size = cur_size; }
             // And child blocks
             for child_scope in &scope.nested {
                 determine_max_stack_size(heap, *child_scope, max_size);
+            }
+        }
         let mut max_stack_size = 0;
         determine_max_stack_size(heap, outer_scope_id, &mut max_stack_size);
         Frame{
             definition: definition_id,
             monomorph_type_id,
             position: first_statement_id.upcast(),
             expr_stack: VecDeque::with_capacity(128),
             expr_values: VecDeque::with_capacity(128),
             max_stack_size,
+        }
+    }
     /// Prepares a single expression for execution. This involves walking the
     /// expression tree and putting them in the `expr_stack` such that
     /// continuously popping from its back will evaluate the expression. The
     /// results of each expression will be stored by pushing onto `expr_values`.
     pub fn prepare_single_expression(&mut self, heap: &Heap, expr_id: ExpressionId) {
         debug_assert!(self.expr_stack.is_empty());
         self.expr_values.clear(); // May not be empty if last expression result(s) were discarded
         self.serialize_expression(heap, expr_id);
+    }
     /// Prepares multiple expressions for execution (i.e. evaluating all
     /// function arguments or all elements of an array/union literal). Per
     /// expression this works the same as `prepare_single_expression`. However
     /// after each expression is evaluated we insert a `PushValToFront`
     /// instruction
     pub fn prepare_multiple_expressions(&mut self, heap: &Heap, expr_ids: &[ExpressionId]) {
         debug_assert!(self.expr_stack.is_empty());
         self.expr_values.clear();
         for expr_id in expr_ids {
             self.expr_stack.push_back(ExprInstruction::PushValToFront);
             self.serialize_expression(heap, *expr_id);
+        }
+    }
     /// Performs depth-first serialization of expression tree. Let's not care
     /// about performance for a temporary runtime implementation
     fn serialize_expression(&mut self, heap: &Heap, id: ExpressionId) {
         self.expr_stack.push_back(ExprInstruction::EvalExpr(id));
         match &heap[id] {
             Expression::Assignment(expr) => {
                 self.serialize_expression(heap, expr.left);
                 self.serialize_expression(heap, expr.right);
             },
             Expression::Binding(expr) => {
                 self.serialize_expression(heap, expr.bound_to);
                 self.serialize_expression(heap, expr.bound_from);
             },
             Expression::Conditional(expr) => {
                 self.serialize_expression(heap, expr.test);
             },
             Expression::Binary(expr) => {
                 self.serialize_expression(heap, expr.left);
                 self.serialize_expression(heap, expr.right);
             },
             Expression::Unary(expr) => {
                 self.serialize_expression(heap, expr.expression);
             },
             Expression::Indexing(expr) => {
                 self.serialize_expression(heap, expr.index);
                 self.serialize_expression(heap, expr.subject);
             },
             Expression::Slicing(expr) => {
@@ @@ -383,484 +384,486 @@ impl Prompt { @@
                                     if array_inclusive_index_is_invalid(&self.store, subject_heap_pos, index) {
                                         return Err(construct_array_error(self, modules, heap, expr_id, subject_heap_pos, index));
+                                    }
                                     (None, Value::Ref(ValueId::Heap(subject_heap_pos, index as u32)))
                                 },
                                 _ => {
                                     // Our value lives on the expression stack, hence we need to
                                     // clone whatever we're referring to. Then drop the subject.
                                     let subject_heap_pos = match &subject {
                                         Value::String(v) => *v,
                                         Value::Array(v) => *v,
                                         Value::Message(v) => *v,
                                         _ => unreachable!(),
                                     };
                                     if array_inclusive_index_is_invalid(&self.store, subject_heap_pos, index) {
                                         return Err(construct_array_error(self, modules, heap, expr_id, subject_heap_pos, index));
+                                    }
                                     let subject_indexed = Value::Ref(ValueId::Heap(subject_heap_pos, index as u32));
                                     (Some(subject_heap_pos), self.store.clone_value(subject_indexed))
                                 },
                             };
                             cur_frame.expr_values.push_back(value_to_push);
                             self.store.drop_value(deallocate_heap_pos);
                         },
                         Expression::Slicing(expr) => {
                             // Evaluate indices
                             let from_index = cur_frame.expr_values.pop_back().unwrap();
                             let from_index = self.store.maybe_read_ref(&from_index);
                             let to_index = cur_frame.expr_values.pop_back().unwrap();
                             let to_index = self.store.maybe_read_ref(&to_index);
                             debug_assert!(from_index.is_integer() && to_index.is_integer());
                             let from_index = if from_index.is_signed_integer() {
                                 from_index.as_signed_integer()
                             } else {
                                 from_index.as_unsigned_integer() as i64
                             };
                             let to_index = if to_index.is_signed_integer() {
                                 to_index.as_signed_integer()
                             } else {
                                 to_index.as_unsigned_integer() as i64
                             };
                             // Dereference subject if needed
                             let subject = cur_frame.expr_values.pop_back().unwrap();
                             let deref_subject = self.store.maybe_read_ref(&subject);
                             // Slicing needs to produce a copy anyway (with the
                             // current evaluator implementation)
                             enum ValueKind{ Array, String, Message }
                             let (value_kind, array_heap_pos) = match deref_subject {
                                 Value::Array(v) => (ValueKind::Array, *v),
                                 Value::String(v) => (ValueKind::String, *v),
                                 Value::Message(v) => (ValueKind::Message, *v),
                                 _ => unreachable!()
                             };
                             if array_inclusive_index_is_invalid(&self.store, array_heap_pos, from_index) {
                                 return Err(construct_array_error(self, modules, heap, expr.from_index, array_heap_pos, from_index));
+                            }
                             if array_exclusive_index_is_invalid(&self.store, array_heap_pos, to_index) {
                                 return Err(construct_array_error(self, modules, heap, expr.to_index, array_heap_pos, to_index));
+                            }
                             // Again: would love to push directly, but rust...
                             let new_heap_pos = self.store.alloc_heap();
                             debug_assert!(self.store.heap_regions[new_heap_pos as usize].values.is_empty());
                             if to_index > from_index {
                                 let from_index = from_index as usize;
                                 let to_index = to_index as usize;
                                 let mut values = Vec::with_capacity(to_index - from_index);
                                 for idx in from_index..to_index {
                                     let value = self.store.heap_regions[array_heap_pos as usize].values[idx].clone();
                                     values.push(self.store.clone_value(value));
+                                }
                                 self.store.heap_regions[new_heap_pos as usize].values = values;
                             } // else: empty range
                             cur_frame.expr_values.push_back(match value_kind {
                                 ValueKind::Array => Value::Array(new_heap_pos),
                                 ValueKind::String => Value::String(new_heap_pos),
                                 ValueKind::Message => Value::Message(new_heap_pos),
                             });
                             // Dropping the original subject, because we don't
                             // want to drop something on the stack
                             self.store.drop_value(subject.get_heap_pos());
                         },
                         Expression::Select(expr) => {
                             let subject= cur_frame.expr_values.pop_back().unwrap();
                             let mono_data = types.get_procedure_monomorph(cur_frame.monomorph_type_id);
                             let field_idx = mono_data.expr_data[expr.unique_id_in_definition as usize].field_or_monomorph_idx as u32;
                             let mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];
                             let field_idx = mono_data.expr_info[expr.type_index as usize].variant.as_select() as u32;
                             // Note: same as above: clone if value lives on expr stack, simply
                             // refer to it if it already lives on the stack/heap.
                             let (deallocate_heap_pos, value_to_push) = match subject {
                                 Value::Ref(value_ref) => {
                                     let subject = self.store.read_ref(value_ref);
                                     let subject_heap_pos = match expr.kind {
                                         SelectKind::StructField(_) => subject.as_struct(),
                                         SelectKind::TupleMember(_) => subject.as_tuple(),
                                     };
                                     (None, Value::Ref(ValueId::Heap(subject_heap_pos, field_idx)))
                                 },
                                 _ => {
                                     let subject_heap_pos = match expr.kind {
                                         SelectKind::StructField(_) => subject.as_struct(),
                                         SelectKind::TupleMember(_) => subject.as_tuple(),
                                     };
                                     let subject_indexed = Value::Ref(ValueId::Heap(subject_heap_pos, field_idx));
                                     (Some(subject_heap_pos), self.store.clone_value(subject_indexed))
                                 },
                             };
                             cur_frame.expr_values.push_back(value_to_push);
                             self.store.drop_value(deallocate_heap_pos);
                         },
                         Expression::Literal(expr) => {
                             let value = match &expr.value {
                                 Literal::Null => Value::Null,
                                 Literal::True => Value::Bool(true),
                                 Literal::False => Value::Bool(false),
                                 Literal::Character(lit_value) => Value::Char(*lit_value),
                                 Literal::String(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     let value = lit_value.as_str();
                                     debug_assert!(values.is_empty());
                                     values.reserve(value.len());
                                     for character in value.as_bytes() {
                                         debug_assert!(character.is_ascii());
                                         values.push(Value::Char(*character as char));
+                                    }
                                     Value::String(heap_pos)
+                                }
                                 Literal::Integer(lit_value) => {
                                     use ConcreteTypePart as CTP;
                                     let def_types = types.get_procedure_monomorph(cur_frame.monomorph_type_id);
                                     let concrete_type = &def_types.expr_data[expr.unique_id_in_definition as usize].expr_type;
                                     let mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];
                                     let type_id = mono_data.expr_info[expr.type_index as usize].type_id;
                                     let concrete_type = &types.get_monomorph(type_id).concrete_type;
                                     debug_assert_eq!(concrete_type.parts.len(), 1);
                                     match concrete_type.parts[0] {
                                         CTP::UInt8  => Value::UInt8(lit_value.unsigned_value as u8),
                                         CTP::UInt16 => Value::UInt16(lit_value.unsigned_value as u16),
                                         CTP::UInt32 => Value::UInt32(lit_value.unsigned_value as u32),
                                         CTP::UInt64 => Value::UInt64(lit_value.unsigned_value as u64),
                                         CTP::SInt8  => Value::SInt8(lit_value.unsigned_value as i8),
                                         CTP::SInt16 => Value::SInt16(lit_value.unsigned_value as i16),
                                         CTP::SInt32 => Value::SInt32(lit_value.unsigned_value as i32),
                                         CTP::SInt64 => Value::SInt64(lit_value.unsigned_value as i64),
                                         _ => unreachable!("got concrete type {:?} for integer literal at expr {:?}", concrete_type, expr_id),
+                                    }
+                                }
                                 Literal::Struct(lit_value) => {
                                     let heap_pos = transfer_expression_values_front_into_heap(
                                         cur_frame, &mut self.store, lit_value.fields.len()
                                     );
                                     Value::Struct(heap_pos)
+                                }
                                 Literal::Enum(lit_value) => {
                                     Value::Enum(lit_value.variant_idx as i64)
+                                }
                                 Literal::Union(lit_value) => {
                                     let heap_pos = transfer_expression_values_front_into_heap(
                                         cur_frame, &mut self.store, lit_value.values.len()
                                     );
                                     Value::Union(lit_value.variant_idx as i64, heap_pos)
+                                }
                                 Literal::Array(lit_value) => {
                                     let heap_pos = transfer_expression_values_front_into_heap(
                                         cur_frame, &mut self.store, lit_value.len()
                                     );
                                     Value::Array(heap_pos)
+                                }
                                 Literal::Tuple(lit_value) => {
                                     let heap_pos = transfer_expression_values_front_into_heap(
                                         cur_frame, &mut self.store, lit_value.len()
                                     );
                                     Value::Tuple(heap_pos)
+                                }
                             };
                             cur_frame.expr_values.push_back(value);
                         },
                         Expression::Cast(expr) => {
                             let mono_data = types.get_procedure_monomorph(cur_frame.monomorph_type_id);
                             let output_type = &mono_data.expr_data[expr.unique_id_in_definition as usize].expr_type;
                             let mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];
                             let type_id = mono_data.expr_info[expr.type_index as usize].type_id;
                             let concrete_type = &types.get_monomorph(type_id).concrete_type;
                             // Typechecking reduced this to two cases: either we
                             // have casting noop (same types), or we're casting
                             // between integer/bool/char types.
                             let subject = cur_frame.expr_values.pop_back().unwrap();
-                            match apply_casting(&mut self.store, output_type, &subject) {
+                            match apply_casting(&mut self.store, concrete_type, &subject) {
                                 Ok(value) => cur_frame.expr_values.push_back(value),
                                 Err(msg) => {
                                     return Err(EvalError::new_error_at_expr(self, modules, heap, expr.this.upcast(), msg));
+                                }
+                            }
                             self.store.drop_value(subject.get_heap_pos());
+                        }
                         Expression::Call(expr) => {
                             // If we're dealing with a builtin we don't do any
                             // fancy shenanigans at all, just push the result.
                             match expr.method {
                                 Method::Get => {
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let value = self.store.maybe_read_ref(&value).clone();
                                     let port_id = if let Value::Input(port_id) = value {
                                         port_id
                                     } else {
                                         unreachable!("executor calling 'get' on value {:?}", value)
                                     };
                                     match ctx.performed_get(port_id) {
                                         Some(result) => {
                                             // We have the result. Merge the `ValueGroup` with the
                                             // stack/heap storage.
                                             debug_assert_eq!(result.values.len(), 1);
                                             result.into_stack(&mut cur_frame.expr_values, &mut self.store);
                                         },
                                         None => {
                                             // Don't have the result yet, prepare the expression to
                                             // get run again after we've received a message.
                                             cur_frame.expr_values.push_front(value.clone());
                                             cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr_id));
                                             return Ok(EvalContinuation::BlockGet(port_id));
+                                        }
+                                    }
                                 },
                                 Method::Put => {
                                     let port_value = cur_frame.expr_values.pop_front().unwrap();
                                     let deref_port_value = self.store.maybe_read_ref(&port_value).clone();
                                     let port_id = if let Value::Output(port_id) = deref_port_value {
                                         port_id
                                     } else {
                                         unreachable!("executor calling 'put' on value {:?}", deref_port_value)
                                     };
                                     let msg_value = cur_frame.expr_values.pop_front().unwrap();
                                     let deref_msg_value = self.store.maybe_read_ref(&msg_value).clone();
                                     if ctx.performed_put(port_id) {
                                         // We're fine, deallocate in case the expression value stack
                                         // held an owned value
                                         self.store.drop_value(msg_value.get_heap_pos());
                                     } else {
                                         // Prepare to execute again
                                         cur_frame.expr_values.push_front(msg_value);
                                         cur_frame.expr_values.push_front(port_value);
                                         cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr_id));
                                         let value_group = ValueGroup::from_store(&self.store, &[deref_msg_value]);
                                         return Ok(EvalContinuation::Put(port_id, value_group));
+                                    }
                                 },
                                 Method::Fires => {
                                     let port_value = cur_frame.expr_values.pop_front().unwrap();
                                     let port_value_deref = self.store.maybe_read_ref(&port_value).clone();
                                     let port_id = match port_value_deref {
                                         Value::Input(port_id) => port_id,
                                         Value::Output(port_id) => port_id,
                                         _ => unreachable!("executor calling 'fires' on value {:?}", port_value_deref),
                                     };
                                     match ctx.fires(port_id) {
                                         None => {
                                             cur_frame.expr_values.push_front(port_value);
                                             cur_frame.expr_stack.push_back(ExprInstruction::EvalExpr(expr_id));
                                             return Ok(EvalContinuation::BlockFires(port_id));
                                         },
                                         Some(value) => {
                                             cur_frame.expr_values.push_back(value);
+                                        }
+                                    }
                                 },
                                 Method::Create => {
                                     let length_value = cur_frame.expr_values.pop_front().unwrap();
                                     let length_value = self.store.maybe_read_ref(&length_value);
                                     let length = if length_value.is_signed_integer() {
                                         let length_value = length_value.as_signed_integer();
                                         if length_value < 0 {
                                             return Err(EvalError::new_error_at_expr(
                                                 self, modules, heap, expr_id,
                                                 format!("got length '{}', can only create a message with a non-negative length", length_value)
                                             ));
+                                        }
                                         length_value as u64
                                     } else {
                                         debug_assert!(length_value.is_unsigned_integer());
                                         length_value.as_unsigned_integer()
                                     };
                                     let heap_pos = self.store.alloc_heap();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
                                     debug_assert!(values.is_empty());
                                     values.resize(length as usize, Value::UInt8(0));
                                     cur_frame.expr_values.push_back(Value::Message(heap_pos));
                                 },
                                 Method::Length => {
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let value_heap_pos = value.get_heap_pos();
                                     let value = self.store.maybe_read_ref(&value);
                                     let heap_pos = match value {
                                         Value::Array(pos) => *pos,
                                         Value::String(pos) => *pos,
                                         _ => unreachable!("length(...) on {:?}", value),
                                     };
                                     let len = self.store.heap_regions[heap_pos as usize].values.len();
                                     // TODO: @PtrInt
                                     cur_frame.expr_values.push_back(Value::UInt32(len as u32));
                                     self.store.drop_value(value_heap_pos);
                                 },
                                 Method::Assert => {
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let value = self.store.maybe_read_ref(&value).clone();
                                     if !value.as_bool() {
                                         return Ok(EvalContinuation::BranchInconsistent)
+                                    }
                                 },
                                 Method::Print => {
                                     // Convert the runtime-variant of a string
                                     // into an actual string.
                                     let value = cur_frame.expr_values.pop_front().unwrap();
                                     let value_heap_pos = value.as_string();
                                     let elements = &self.store.heap_regions[value_heap_pos as usize].values;
                                     let mut message = String::with_capacity(elements.len());
                                     for element in elements {
                                         message.push(element.as_char());
+                                    }
                                     // Drop the heap-allocated value from the
                                     // store
                                     self.store.drop_heap_pos(value_heap_pos);
                                     println!("{}", message);
                                 },
                                 Method::SelectStart => {
                                     todo!("select start");
                                 },
                                 Method::SelectRegisterCasePort => {
                                     todo!("select register");
                                 },
                                 Method::SelectWait => {
                                     todo!("select wait");
                                 },
                                 Method::UserComponent => {
                                     // This is actually handled by the evaluation
                                     // of the statement.
                                     debug_assert_eq!(heap[expr.procedure].parameters.len(), cur_frame.expr_values.len());
                                     debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this)
                                 },
-                                Method::UserProcedure => {
+                                Method::UserFunction => {
                                     // Push a new frame. Note that all expressions have
                                     // been pushed to the front, so they're in the order
                                     // of the definition.
                                     let num_args = expr.arguments.len();
                                     // Determine stack boundaries
                                     let cur_stack_boundary = self.store.cur_stack_boundary;
                                     let new_stack_boundary = self.store.stack.len();
                                     // Push new boundary and function arguments for new frame
                                     self.store.stack.push(Value::PrevStackBoundary(cur_stack_boundary as isize));
                                     for _ in 0..num_args {
                                         let argument = self.store.read_take_ownership(cur_frame.expr_values.pop_front().unwrap());
                                         self.store.stack.push(argument);
+                                    }
                                     // Determine the monomorph index of the function we're calling
                                     let mono_data = types.get_procedure_monomorph(cur_frame.monomorph_type_id);
                                     let call_data = &mono_data.expr_data[expr.unique_id_in_definition as usize];
                                     let mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];
                                     let type_id = mono_data.expr_info[expr.type_index as usize].variant.as_procedure().0;
                                     // Push the new frame and reserve its stack size
-                                    let new_frame = Frame::new(heap, expr.procedure, call_data.type_id);
                                     let new_frame = Frame::new(heap, expr.procedure, type_id);
                                     let new_stack_size = new_frame.max_stack_size;
                                     self.frames.push(new_frame);
                                     self.store.cur_stack_boundary = new_stack_boundary;
                                     self.store.reserve_stack(new_stack_size);
                                     // To simplify the logic a little bit we will now
                                     // return and ask our caller to call us again
                                     return Ok(EvalContinuation::Stepping);
+                                }
+                            }
                         },
                         Expression::Variable(expr) => {
                             let variable = &heap[expr.declaration.unwrap()];
                             let ref_value = if expr.used_as_binding_target {
                                 Value::Binding(variable.unique_id_in_scope as StackPos)
                             } else {
                                 Value::Ref(ValueId::Stack(variable.unique_id_in_scope as StackPos))
                             };
                             cur_frame.expr_values.push_back(ref_value);
+                        }
+                    }
+                }
+            }
+        }
         debug_log!("Frame [{:?}] at {:?}", cur_frame.definition, cur_frame.position);
         if debug_enabled!() {
             debug_log!("Expression value stack (size = {}):", cur_frame.expr_values.len());
             for (_stack_idx, _stack_val) in cur_frame.expr_values.iter().enumerate() {
                 debug_log!("  [{:03}] {:?}", _stack_idx, _stack_val);
+            }
             debug_log!("Stack (size = {}):", self.store.stack.len());
             for (_stack_idx, _stack_val) in self.store.stack.iter().enumerate() {
                 debug_log!("  [{:03}] {:?}", _stack_idx, _stack_val);
+            }
             debug_log!("Heap:");
             for (_heap_idx, _heap_region) in self.store.heap_regions.iter().enumerate() {
                 let _is_free = self.store.free_regions.iter().any(|idx| *idx as usize == _heap_idx);
                 debug_log!("  [{:03}] in_use: {}, len: {}, vals: {:?}", _heap_idx, !_is_free, _heap_region.values.len(), &_heap_region.values);
+            }
+        }
         // No (more) expressions to evaluate. So evaluate statement (that may
         // depend on the result on the last evaluated expression(s))
         let stmt = &heap[cur_frame.position];
         let return_value = match stmt {
             Statement::Block(stmt) => {
                 debug_assert!(stmt.statements.is_empty() || stmt.next == stmt.statements[0]);
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndBlock(stmt) => {
                 let block = &heap[stmt.start_block];
                 let scope = &heap[block.scope];
                 self.store.clear_stack(scope.first_unique_id_in_scope as usize);
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Local(stmt) => {
                 match stmt {
                     LocalStatement::Memory(stmt) => {
                         dbg_code!({
                             let variable = &heap[stmt.variable];
                             debug_assert!(match self.store.read_ref(ValueId::Stack(variable.unique_id_in_scope as u32)) {
                                 Value::Unassigned => false,
                                 _ => true,
                             });
                         });
                         cur_frame.position = stmt.next;
                         Ok(EvalContinuation::Stepping)
                     },
                     LocalStatement::Channel(stmt) => {
                         // Need to create a new channel by requesting it from
                         // the runtime.
                         match ctx.created_channel() {
                             None => {
                                 // No channel is pending. So request one
                                     Ok(EvalContinuation::NewChannel)
                             },
                             Some((put_port, get_port)) => {
                                 self.store.write(ValueId::Stack(heap[stmt.from].unique_id_in_scope as u32), put_port);
                                 self.store.write(ValueId::Stack(heap[stmt.to].unique_id_in_scope as u32), get_port);
                                 cur_frame.position = stmt.next;
                                 Ok(EvalContinuation::Stepping)
+                            }
+                        }
+                    }
+                }
             },
             Statement::Labeled(stmt) => {
                 cur_frame.position = stmt.body;
                 Ok(EvalContinuation::Stepping)
@@ @@ -932,197 +935,196 @@ impl Prompt { @@
                 self.store.clear_stack(scope.first_unique_id_in_scope as usize);
                 Ok(EvalContinuation::SyncBlockEnd)
             },
             Statement::Fork(stmt) => {
                 if stmt.right_body.is_none() {
                     // No reason to fork
                     cur_frame.position = stmt.left_body;
                 } else {
                     // Need to fork
                     if let Some(go_left) = ctx.performed_fork() {
                         // Runtime has created a fork
                         if go_left {
                             cur_frame.position = stmt.left_body;
                         } else {
                             cur_frame.position = stmt.right_body.unwrap();
+                        }
                     } else {
                         // Request the runtime to create a fork of the current
                         // branch
                         return Ok(EvalContinuation::NewFork);
+                    }
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::EndFork(stmt) => {
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Select(_stmt) => {
                 todo!("implement select evaluation")
             },
             Statement::EndSelect(stmt) => {
                 cur_frame.position = stmt.next;
                 let start_select = &heap[stmt.start_select];
                 if let Some(select_case) = start_select.cases.first() {
                     let scope = &heap[select_case.scope];
                     self.store.clear_stack(scope.first_unique_id_in_scope as usize);
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Return(_stmt) => {
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for return statement");
                 // The preceding frame has executed a call, so is expecting the
                 // return expression on its expression value stack. Note that
                 // we may be returning a reference to something on our stack,
                 // so we need to read that value and clone it.
                 let return_value = cur_frame.expr_values.pop_back().unwrap();
                 let return_value = match return_value {
                     Value::Ref(value_id) => self.store.read_copy(value_id),
                     _ => return_value,
                 };
                 // Pre-emptively pop our stack frame
                 self.frames.pop();
                 // Clean up our section of the stack
                 self.store.clear_stack(0);
                 self.store.stack.truncate(self.store.cur_stack_boundary + 1);
                 let prev_stack_idx = self.store.stack.pop().unwrap().as_stack_boundary();
                 // TODO: Temporary hack for testing, remove at some point
                 if self.frames.is_empty() {
                     debug_assert!(prev_stack_idx == -1);
                     debug_assert!(self.store.stack.len() == 0);
                     self.store.stack.push(return_value);
                     return Ok(EvalContinuation::ComponentTerminated);
+                }
                 debug_assert!(prev_stack_idx >= 0);
                 // Return to original state of stack frame
                 self.store.cur_stack_boundary = prev_stack_idx as usize;
                 let cur_frame = self.frames.last_mut().unwrap();
                 cur_frame.expr_values.push_back(return_value);
                 // We just returned to the previous frame, which might be in
                 // the middle of evaluating expressions for a particular
                 // statement. So we don't want to enter the code below.
                 return Ok(EvalContinuation::Stepping);
             },
             Statement::Goto(stmt) => {
                 cur_frame.position = stmt.target.upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::New(stmt) => {
                 let call_expr = &heap[stmt.expression];
                 debug_assert_eq!(
                     cur_frame.expr_values.len(), heap[call_expr.procedure].parameters.len(),
                     "mismatch in expr stack size and number of arguments for new statement"
                 );
                 let mono_data = types.get_procedure_monomorph(cur_frame.monomorph_type_id);
                 let expr_data = &mono_data.expr_data[call_expr.unique_id_in_definition as usize];
                 let mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];
                 let type_id = mono_data.expr_info[expr.type_index as usize].variant.as_procedure().0;
                 // Note that due to expression value evaluation they exist in
                 // reverse order on the stack.
                 // TODO: Revise this code, keep it as is to be compatible with current runtime
                 let mut args = Vec::new();
                 while let Some(value) = cur_frame.expr_values.pop_front() {
                     args.push(value);
+                }
                 // Construct argument group, thereby copying heap regions
                 let argument_group = ValueGroup::from_store(&self.store, &args);
                 // println!("Creating {} with\n{:#?}", heap[call_expr.definition].identifier().value.as_str(), argument_group);
                 // Clear any heap regions
                 for arg in &args {
                     self.store.drop_value(arg.get_heap_pos());
+                }
                 cur_frame.position = stmt.next;
-                Ok(EvalContinuation::NewComponent(call_expr.procedure, expr_data.type_id, argument_group))
                 Ok(EvalContinuation::NewComponent(call_expr.procedure, type_id, argument_group))
             },
             Statement::Expression(stmt) => {
                 // The expression has just been completely evaluated. Some
                 // values might have remained on the expression value stack.
                 // cur_frame.expr_values.clear(); PROPER CLEARING
                 cur_frame.position = stmt.next;
                 Ok(EvalContinuation::Stepping)
             },
         };
         assert!(
             cur_frame.expr_values.is_empty(),
             "This is a debugging assertion that will fail if you perform expressions without \
             assigning to anything. This should be completely valid, and this assertion should be \
             replaced by something that clears the expression values if needed, but I'll keep this \
             in for now for debugging purposes."
         );
         // If the next statement requires evaluating expressions then we push
         // these onto the expression stack. This way we will evaluate this
         // stack in the next loop, then evaluate the statement using the result
         // from the expression evaluation.
         if !cur_frame.position.is_invalid() {
             let stmt = &heap[cur_frame.position];
             match stmt {
                 Statement::Local(stmt) => {
                     if let LocalStatement::Memory(stmt) = stmt {
                         // Setup as unassigned, when we execute the memory
                         // statement (after evaluating expression), it should no
                         // longer be `Unassigned`.
                         let variable = &heap[stmt.variable];
                         self.store.write(ValueId::Stack(variable.unique_id_in_scope as u32), Value::Unassigned);
                         cur_frame.prepare_single_expression(heap, stmt.initial_expr.upcast());
+                    }
                 },
                 Statement::If(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),
                 Statement::While(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),
                 Statement::Return(stmt) => {
                     debug_assert_eq!(stmt.expressions.len(), 1); // TODO: @ReturnValues
                     cur_frame.prepare_single_expression(heap, stmt.expressions[0]);
                 },
                 Statement::New(stmt) => {
                     // Note that we will end up not evaluating the call itself.
                     // Rather we will evaluate its expressions and then
                     // instantiate the component upon reaching the "new" stmt.
                     let call_expr = &heap[stmt.expression];
                     cur_frame.prepare_multiple_expressions(heap, &call_expr.arguments);
                 },
                 Statement::Expression(stmt) => {
                     cur_frame.prepare_single_expression(heap, stmt.expression);
+                }
                 _ => {},
+            }
+        }
         return_value
+    }
     /// Constructs an error at the current expression that lives at the top of
     /// the expression stack. Falls back to constructing an error at the current
     /// statement if there is no expression.
     pub(crate) fn new_error_at_expr(&self, modules: &[Module], heap: &Heap, error_message: String) -> EvalError {
         let last_frame = self.frames.last().unwrap();
         for instruction in last_frame.expr_stack.iter().rev() {
             if let ExprInstruction::EvalExpr(expression_id) = instruction {
                 return EvalError::new_error_at_expr(
                     self, modules, heap, *expression_id, error_message
                 );
+            }
+        }
         // If here then expression stack was empty (cannot have just rotate
         // instructions)
         panic!("attempted to construct evaluation error without any expressions to evaluate in frame");
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -666,1165 +666,1165 @@ impl PassDefinitions { @@
             let block = self.consume_statement(module, iter, ctx)?;
             cases.push(SelectCase{
                 guard,
                 body: block,
                 scope: ScopeId::new_invalid(),
                 involved_ports: Vec::with_capacity(1)
             });
             next = iter.next();
+        }
         consume_token(&module.source, iter, TokenKind::CloseCurly)?;
         let num_cases = cases.len();
         let select_stmt_id = ctx.heap.alloc_select_statement(|this| SelectStatement{
             this,
             span: select_span,
             cases,
             end_select: EndSelectStatementId::new_invalid(),
             relative_pos_in_parent: -1,
             next: StatementId::new_invalid(),
         });
         let end_select_stmt_id = ctx.heap.alloc_end_select_statement(|this| EndSelectStatement{
             this,
             start_select: select_stmt_id,
             next: StatementId::new_invalid(),
         });
         let select_stmt = &mut ctx.heap[select_stmt_id];
         select_stmt.end_select = end_select_stmt_id;
         for case_index in 0..num_cases {
             let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::SelectCase(select_stmt_id, case_index as u32)));
             let select_stmt = &mut ctx.heap[select_stmt_id];
             let select_case = &mut select_stmt.cases[case_index];
             select_case.scope = scope_id;
+        }
         return Ok(select_stmt_id)
+    }
     fn consume_return_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ReturnStatementId, ParseError> {
         let return_span = consume_exact_ident(&module.source, iter, KW_STMT_RETURN)?;
         let mut scoped_section = self.expressions.start_section();
         consume_comma_separated_until(
             TokenKind::SemiColon, &module.source, iter, ctx,
             |_source, iter, ctx| self.consume_expression(module, iter, ctx),
             &mut scoped_section, "an expression", None
         )?;
         let expressions = scoped_section.into_vec();
         if expressions.is_empty() {
             return Err(ParseError::new_error_str_at_span(&module.source, return_span, "expected at least one return value"));
         } else if expressions.len() > 1 {
             return Err(ParseError::new_error_str_at_span(&module.source, return_span, "multiple return values are not (yet) supported"))
+        }
         Ok(ctx.heap.alloc_return_statement(|this| ReturnStatement{
             this,
             span: return_span,
             expressions
         }))
+    }
     fn consume_goto_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<GotoStatementId, ParseError> {
         let goto_span = consume_exact_ident(&module.source, iter, KW_STMT_GOTO)?;
         let label = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_goto_statement(|this| GotoStatement{
             this,
             span: goto_span,
             label,
             target: LabeledStatementId::new_invalid(),
         }))
+    }
     fn consume_new_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<NewStatementId, ParseError> {
         let new_span = consume_exact_ident(&module.source, iter, KW_STMT_NEW)?;
         let start_pos = iter.last_valid_pos();
         let expression_id = self.consume_primary_expression(module, iter, ctx)?;
         let expression = &ctx.heap[expression_id];
         let mut valid = false;
         let mut call_id = CallExpressionId::new_invalid();
         if let Expression::Call(expression) = expression {
             // Allow both components and functions, as it makes more sense to
             // check their correct use in the validation and linking pass
-            if expression.method == Method::UserComponent || expression.method == Method::UserProcedure {
+            if expression.method == Method::UserComponent || expression.method == Method::UserFunction {
                 call_id = expression.this;
                 valid = true;
+            }
+        }
         if !valid {
             return Err(ParseError::new_error_str_at_span(
                 &module.source, InputSpan::from_positions(start_pos, iter.last_valid_pos()), "expected a call expression"
             ));
+        }
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         debug_assert!(!call_id.is_invalid());
         Ok(ctx.heap.alloc_new_statement(|this| NewStatement{
             this,
             span: new_span,
             expression: call_id,
             next: StatementId::new_invalid(),
         }))
+    }
     fn consume_channel_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ChannelStatementId, ParseError> {
         // Consume channel specification
         let channel_span = consume_exact_ident(&module.source, iter, KW_STMT_CHANNEL)?;
         let (inner_port_type, end_pos) = if Some(TokenKind::OpenAngle) == iter.next() {
             // Retrieve the type of the channel, we're cheating a bit here by
             // consuming the first '<' and setting the initial angle depth to 1
             // such that our final '>' will be consumed as well.
             let angle_start_pos = iter.next_start_position();
             iter.consume();
             let definition_id = self.cur_definition;
             let poly_vars = ctx.heap[definition_id].poly_vars();
             let parser_type = self.type_parser.consume_parser_type(
                 iter, &ctx.heap, &module.source, &ctx.symbols, poly_vars,
                 definition_id, SymbolScope::Module(module.root_id),
                 true, Some(angle_start_pos)
             )?;
             (parser_type.elements, parser_type.full_span.end)
         } else {
             // Assume inferred
+            (
                 vec![ParserTypeElement{
                     element_span: channel_span,
                     variant: ParserTypeVariant::Inferred
                 }],
                 channel_span.end
+            )
         };
         let from_identifier = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::ArrowRight)?;
         let to_identifier = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         // Construct ports
         let port_type_span = InputSpan::from_positions(channel_span.begin, end_pos);
         let port_type_len = inner_port_type.len() + 1;
         let mut from_port_type = ParserType{ elements: Vec::with_capacity(port_type_len), full_span: port_type_span };
         from_port_type.elements.push(ParserTypeElement{
             element_span: channel_span,
             variant: ParserTypeVariant::Output,
         });
         from_port_type.elements.extend_from_slice(&inner_port_type);
         let from = ctx.heap.alloc_variable(|this| Variable{
             this,
             kind: VariableKind::Local,
             identifier: from_identifier,
             parser_type: from_port_type,
             relative_pos_in_parent: 0,
             unique_id_in_scope: -1,
         });
         let mut to_port_type = ParserType{ elements: Vec::with_capacity(port_type_len), full_span: port_type_span };
         to_port_type.elements.push(ParserTypeElement{
             element_span: channel_span,
             variant: ParserTypeVariant::Input
         });
         to_port_type.elements.extend_from_slice(&inner_port_type);
         let to = ctx.heap.alloc_variable(|this|Variable{
             this,
             kind: VariableKind::Local,
             identifier: to_identifier,
             parser_type: to_port_type,
             relative_pos_in_parent: 0,
             unique_id_in_scope: -1,
         });
         // Construct the channel
         Ok(ctx.heap.alloc_channel_statement(|this| ChannelStatement{
             this,
             span: channel_span,
             from, to,
             relative_pos_in_parent: 0,
             next: StatementId::new_invalid(),
         }))
+    }
     fn consume_labeled_statement(&mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx) -> Result<LabeledStatementId, ParseError> {
         let label = consume_ident_interned(&module.source, iter, ctx)?;
         consume_token(&module.source, iter, TokenKind::Colon)?;
         let inner_stmt_id = self.consume_statement(module, iter, ctx)?;
         let stmt_id = ctx.heap.alloc_labeled_statement(|this| LabeledStatement {
             this,
             label,
             body: inner_stmt_id,
             relative_pos_in_parent: 0,
             in_sync: SynchronousStatementId::new_invalid(),
         });
         return Ok(stmt_id);
+    }
     /// Attempts to consume a memory statement (a statement along the lines of
     /// `type var_name = initial_expr`). Will return `Ok(None)` if it didn't
     /// seem like there was a memory statement, `Ok(Some(...))` if there was
     /// one, and `Err(...)` if its reasonable to assume that there was a memory
     /// statement, but we failed to parse it.
     fn maybe_consume_memory_statement_without_semicolon(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<Option<MemoryStatementId>, ParseError> {
         // This is a bit ugly. It would be nicer if we could somehow
         // consume the expression with a type hint if we do get a valid
         // type, but we don't get an identifier following it
         let iter_state = iter.save();
         let definition_id = self.cur_definition;
         let poly_vars = ctx.heap[definition_id].poly_vars();
         let parser_type = self.type_parser.consume_parser_type(
             iter, &ctx.heap, &module.source, &ctx.symbols, poly_vars,
             definition_id, SymbolScope::Definition(definition_id), true, None
         );
         if let Ok(parser_type) = parser_type {
             if Some(TokenKind::Ident) == iter.next() {
                 // Assume this is a proper memory statement
                 let identifier = consume_ident_interned(&module.source, iter, ctx)?;
                 let memory_span = InputSpan::from_positions(parser_type.full_span.begin, identifier.span.end);
                 let assign_span = consume_token(&module.source, iter, TokenKind::Equal)?;
                 let initial_expr_id = self.consume_expression(module, iter, ctx)?;
                 let initial_expr_end_pos = iter.last_valid_pos();
                 // Create the AST variable
                 let local_id = ctx.heap.alloc_variable(|this| Variable{
                     this,
                     kind: VariableKind::Local,
                     identifier: identifier.clone(),
                     parser_type,
                     relative_pos_in_parent: 0,
                     unique_id_in_scope: -1,
                 });
                 // Create the initial assignment expression
                 // Note: we set the initial variable declaration here
                 let variable_expr_id = ctx.heap.alloc_variable_expression(|this| VariableExpression{
                     this,
                     identifier,
                     declaration: Some(local_id),
                     used_as_binding_target: false,
                     parent: ExpressionParent::None,
-                    unique_id_in_definition: -1,
+                    type_index: -1,
                 });
                 let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                     this,
                     operator_span: assign_span,
                     full_span: InputSpan::from_positions(memory_span.begin, initial_expr_end_pos),
                     left: variable_expr_id.upcast(),
                     operation: AssignmentOperator::Set,
                     right: initial_expr_id,
                     parent: ExpressionParent::None,
-                    unique_id_in_definition: -1,
+                    type_index: -1,
                 });
                 // Put both together in the memory statement
                 let memory_stmt_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{
                     this,
                     span: memory_span,
                     variable: local_id,
                     initial_expr: assignment_expr_id,
                     next: StatementId::new_invalid()
                 });
                 return Ok(Some(memory_stmt_id));
+            }
+        }
         // If here then one of the preconditions for a memory statement was not
         // met. So recover the iterator and return
         iter.load(iter_state);
         Ok(None)
+    }
     fn consume_expression_statement(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionStatementId, ParseError> {
         let start_pos = iter.last_valid_pos();
         let expression = self.consume_expression(module, iter, ctx)?;
         let end_pos = iter.last_valid_pos();
         consume_token(&module.source, iter, TokenKind::SemiColon)?;
         Ok(ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
             this,
             span: InputSpan::from_positions(start_pos, end_pos),
             expression,
             next: StatementId::new_invalid(),
         }))
+    }
     //--------------------------------------------------------------------------
     // Expression Parsing
     //--------------------------------------------------------------------------
     // TODO: @Cleanup This is fine for now. But I prefer my stacktraces not to
     //  look like enterprise Java code...
     fn consume_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_assignment_expression(module, iter, ctx)
+    }
     fn consume_assignment_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         // Utility to convert token into assignment operator
         fn parse_assignment_operator(token: Option<TokenKind>) -> Option<AssignmentOperator> {
             use TokenKind as TK;
             use AssignmentOperator as AO;
             if token.is_none() {
                 return None
+            }
             match token.unwrap() {
                 TK::Equal               => Some(AO::Set),
                 TK::AtEquals            => Some(AO::Concatenated),
                 TK::StarEquals          => Some(AO::Multiplied),
                 TK::SlashEquals         => Some(AO::Divided),
                 TK::PercentEquals       => Some(AO::Remained),
                 TK::PlusEquals          => Some(AO::Added),
                 TK::MinusEquals         => Some(AO::Subtracted),
                 TK::ShiftLeftEquals     => Some(AO::ShiftedLeft),
                 TK::ShiftRightEquals    => Some(AO::ShiftedRight),
                 TK::AndEquals           => Some(AO::BitwiseAnded),
                 TK::CaretEquals         => Some(AO::BitwiseXored),
                 TK::OrEquals            => Some(AO::BitwiseOred),
                 _                       => None
+            }
+        }
         let expr = self.consume_conditional_expression(module, iter, ctx)?;
         if let Some(operation) = parse_assignment_operator(iter.next()) {
             let operator_span = iter.next_span();
             iter.consume();
             let left = expr;
             let right = self.consume_expression(module, iter, ctx)?;
             let full_span = InputSpan::from_positions(
                 ctx.heap[left].full_span().begin,
                 ctx.heap[right].full_span().end,
             );
             Ok(ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
                 this, operator_span, full_span, left, operation, right,
                 parent: ExpressionParent::None,
-                unique_id_in_definition: -1,
+                type_index: -1,
             }).upcast())
         } else {
             Ok(expr)
+        }
+    }
     fn consume_conditional_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         let result = self.consume_concat_expression(module, iter, ctx)?;
         if let Some(TokenKind::Question) = iter.next() {
             let operator_span = iter.next_span();
             iter.consume();
             let test = result;
             let true_expression = self.consume_expression(module, iter, ctx)?;
             consume_token(&module.source, iter, TokenKind::Colon)?;
             let false_expression = self.consume_expression(module, iter, ctx)?;
             let full_span = InputSpan::from_positions(
                 ctx.heap[test].full_span().begin,
                 ctx.heap[false_expression].full_span().end,
             );
             Ok(ctx.heap.alloc_conditional_expression(|this| ConditionalExpression{
                 this, operator_span, full_span, test, true_expression, false_expression,
                 parent: ExpressionParent::None,
-                unique_id_in_definition: -1,
+                type_index: -1,
             }).upcast())
         } else {
             Ok(result)
+        }
+    }
     fn consume_concat_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::At) => Some(BinaryOperator::Concatenate),
                 _ => None
             },
             Self::consume_logical_or_expression
+        )
+    }
     fn consume_logical_or_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::OrOr) => Some(BinaryOperator::LogicalOr),
                 _ => None
             },
             Self::consume_logical_and_expression
+        )
+    }
     fn consume_logical_and_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::AndAnd) => Some(BinaryOperator::LogicalAnd),
                 _ => None
             },
             Self::consume_bitwise_or_expression
+        )
+    }
     fn consume_bitwise_or_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Or) => Some(BinaryOperator::BitwiseOr),
                 _ => None
             },
             Self::consume_bitwise_xor_expression
+        )
+    }
     fn consume_bitwise_xor_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Caret) => Some(BinaryOperator::BitwiseXor),
                 _ => None
             },
             Self::consume_bitwise_and_expression
+        )
+    }
     fn consume_bitwise_and_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::And) => Some(BinaryOperator::BitwiseAnd),
                 _ => None
             },
             Self::consume_equality_expression
+        )
+    }
     fn consume_equality_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::EqualEqual) => Some(BinaryOperator::Equality),
                 Some(TokenKind::NotEqual) => Some(BinaryOperator::Inequality),
                 _ => None
             },
             Self::consume_relational_expression
+        )
+    }
     fn consume_relational_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::OpenAngle) => Some(BinaryOperator::LessThan),
                 Some(TokenKind::CloseAngle) => Some(BinaryOperator::GreaterThan),
                 Some(TokenKind::LessEquals) => Some(BinaryOperator::LessThanEqual),
                 Some(TokenKind::GreaterEquals) => Some(BinaryOperator::GreaterThanEqual),
                 _ => None
             },
             Self::consume_shift_expression
+        )
+    }
     fn consume_shift_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::ShiftLeft) => Some(BinaryOperator::ShiftLeft),
                 Some(TokenKind::ShiftRight) => Some(BinaryOperator::ShiftRight),
                 _ => None
             },
             Self::consume_add_or_subtract_expression
+        )
+    }
     fn consume_add_or_subtract_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Plus) => Some(BinaryOperator::Add),
                 Some(TokenKind::Minus) => Some(BinaryOperator::Subtract),
                 _ => None,
             },
             Self::consume_multiply_divide_or_modulus_expression
+        )
+    }
     fn consume_multiply_divide_or_modulus_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         self.consume_generic_binary_expression(
             module, iter, ctx,
             |token| match token {
                 Some(TokenKind::Star) => Some(BinaryOperator::Multiply),
                 Some(TokenKind::Slash) => Some(BinaryOperator::Divide),
                 Some(TokenKind::Percent) => Some(BinaryOperator::Remainder),
                 _ => None
             },
             Self::consume_prefix_expression
+        )
+    }
     fn consume_prefix_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         fn parse_prefix_token(token: Option<TokenKind>) -> Option<UnaryOperator> {
             use TokenKind as TK;
             use UnaryOperator as UO;
             match token {
                 Some(TK::Plus) => Some(UO::Positive),
                 Some(TK::Minus) => Some(UO::Negative),
                 Some(TK::Tilde) => Some(UO::BitwiseNot),
                 Some(TK::Exclamation) => Some(UO::LogicalNot),
                 _ => None
+            }
+        }
         let next = iter.next();
         if let Some(operation) = parse_prefix_token(next) {
             let operator_span = iter.next_span();
             iter.consume();
             let expression = self.consume_prefix_expression(module, iter, ctx)?;
             let full_span = InputSpan::from_positions(
                 operator_span.begin, ctx.heap[expression].full_span().end,
             );
             Ok(ctx.heap.alloc_unary_expression(|this| UnaryExpression {
                 this, operator_span, full_span, operation, expression,
                 parent: ExpressionParent::None,
-                unique_id_in_definition: -1,
+                type_index: -1,
             }).upcast())
         } else if next == Some(TokenKind::PlusPlus) {
             return Err(ParseError::new_error_str_at_span(
                 &module.source, iter.next_span(), "prefix increment is not supported in the language"
             ));
         } else if next == Some(TokenKind::MinusMinus) {
             return Err(ParseError::new_error_str_at_span(
                 &module.source, iter.next_span(), "prefix decrement is not supported in this language"
             ));
         } else {
             self.consume_postfix_expression(module, iter, ctx)
+        }
+    }
     fn consume_postfix_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         fn has_matching_postfix_token(token: Option<TokenKind>) -> bool {
             use TokenKind as TK;
             if token.is_none() { return false; }
             match token.unwrap() {
                 TK::PlusPlus | TK::MinusMinus | TK::OpenSquare | TK::Dot => true,
                 _ => false
+            }
+        }
         let mut result = self.consume_primary_expression(module, iter, ctx)?;
         let mut next = iter.next();
         while has_matching_postfix_token(next) {
             let token = next.unwrap();
             let mut operator_span = iter.next_span();
             iter.consume();
             if token == TokenKind::PlusPlus {
                 return Err(ParseError::new_error_str_at_span(
                     &module.source, operator_span, "postfix increment is not supported in this language"
                 ));
             } else if token == TokenKind::MinusMinus {
                 return Err(ParseError::new_error_str_at_span(
                     &module.source, operator_span, "prefix increment is not supported in this language"
                 ));
             } else if token == TokenKind::OpenSquare {
                 let subject = result;
                 let from_index = self.consume_expression(module, iter, ctx)?;
                 // Check if we have an indexing or slicing operation
                 next = iter.next();
                 if Some(TokenKind::DotDot) == next {
                     iter.consume();
                     let to_index = self.consume_expression(module, iter, ctx)?;
                     let end_span = consume_token(&module.source, iter, TokenKind::CloseSquare)?;
                     operator_span.end = end_span.end;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, operator_span.end
                     );
                     result = ctx.heap.alloc_slicing_expression(|this| SlicingExpression{
                         this,
                         slicing_span: operator_span,
                         full_span, subject, from_index, to_index,
                         parent: ExpressionParent::None,
-                        unique_id_in_definition: -1,
+                        type_index: -1,
                     }).upcast();
                 } else if Some(TokenKind::CloseSquare) == next {
                     let end_span = consume_token(&module.source, iter, TokenKind::CloseSquare)?;
                     operator_span.end = end_span.end;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, operator_span.end
                     );
                     result = ctx.heap.alloc_indexing_expression(|this| IndexingExpression{
                         this, operator_span, full_span, subject,
                         index: from_index,
                         parent: ExpressionParent::None,
-                        unique_id_in_definition: -1,
+                        type_index: -1,
                     }).upcast();
                 } else {
                     return Err(ParseError::new_error_str_at_pos(
                         &module.source, iter.last_valid_pos(), "unexpected token: expected ']' or '..'"
                     ));
+                }
             } else {
                 // Can be a select expression for struct fields, or a select
                 // for a tuple element.
                 debug_assert_eq!(token, TokenKind::Dot);
                 let subject = result;
                 let next = iter.next();
                 let (select_kind, full_span) = if Some(TokenKind::Integer) == next {
                     // Tuple member
                     let (index, index_span) = consume_integer_literal(&module.source, iter, &mut self.buffer)?;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, index_span.end
                     );
                     (SelectKind::TupleMember(index), full_span)
                 } else if Some(TokenKind::Ident) == next {
                     // Struct field
                     let field_name = consume_ident_interned(&module.source, iter, ctx)?;
                     let full_span = InputSpan::from_positions(
                         ctx.heap[subject].full_span().begin, field_name.span.end
                     );
                     (SelectKind::StructField(field_name), full_span)
                 } else {
                     return Err(ParseError::new_error_str_at_pos(
                         &module.source, iter.last_valid_pos(), "unexpected token: expected integer or identifier"
                     ));
                 };
                 result = ctx.heap.alloc_select_expression(|this| SelectExpression{
                     this, operator_span, full_span, subject,
                     kind: select_kind,
                     parent: ExpressionParent::None,
-                    unique_id_in_definition: -1,
+                    type_index: -1,
                 }).upcast();
+            }
             next = iter.next();
+        }
         Ok(result)
+    }
     fn consume_primary_expression(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx
     ) -> Result<ExpressionId, ParseError> {
         let next = iter.next();
         let result = if next == Some(TokenKind::OpenParen) {
             // Something parenthesized. This can mean several things: we have
             // a parenthesized expression or we have a tuple literal. They are
             // ambiguous when the tuple has one member. But like the tuple type
             // parsing we interpret all one-tuples as parenthesized expressions.
             //
             // Practically (to prevent unnecessary `consume_expression` calls)
             // we distinguish the zero-tuple, the parenthesized expression, and
             // the N-tuple (for N > 1).
             let open_paren_pos = iter.next_start_position();
             iter.consume();
             let result = if Some(TokenKind::CloseParen) == iter.next() {
                 // Zero-tuple
                 let (_, close_paren_pos) = iter.next_positions();
                 iter.consume();
                 let literal_id = ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                     this,
                     span: InputSpan::from_positions(open_paren_pos, close_paren_pos),
                     value: Literal::Tuple(Vec::new()),
                     parent: ExpressionParent::None,
-                    unique_id_in_definition: -1,
+                    type_index: -1,
                 });
                 literal_id.upcast()
             } else {
                 // Start by consuming one expression, then check for a comma
                 let expr_id = self.consume_expression(module, iter, ctx)?;
                 if Some(TokenKind::Comma) == iter.next() && Some(TokenKind::CloseParen) != iter.peek() {
                     // Must be an N-tuple
                     iter.consume(); // the comma
                     let mut scoped_section = self.expressions.start_section();
                     scoped_section.push(expr_id);
                     let mut close_paren_pos = open_paren_pos;
                     consume_comma_separated_until(
                         TokenKind::CloseParen, &module.source, iter, ctx,
                         |_source, iter, ctx| self.consume_expression(module, iter, ctx),
                         &mut scoped_section, "an expression", Some(&mut close_paren_pos)
                     )?;
                     debug_assert!(scoped_section.len() > 1); // peeked token wasn't CloseParen, must be expression
                     let literal_id = ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                         this,
                         span: InputSpan::from_positions(open_paren_pos, close_paren_pos),
                         value: Literal::Tuple(scoped_section.into_vec()),
                         parent: ExpressionParent::None,
-                        unique_id_in_definition: -1,
+                        type_index: -1,
                     });
                     literal_id.upcast()
                 } else {
                     // Assume we're dealing with a normal expression
                     consume_token(&module.source, iter, TokenKind::CloseParen)?;
                     expr_id
+                }
             };
             result
         } else if next == Some(TokenKind::OpenCurly) {
             // Array literal
             let (start_pos, mut end_pos) = iter.next_positions();
             let mut scoped_section = self.expressions.start_section();
             consume_comma_separated(
                 TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
                 |_source, iter, ctx| self.consume_expression(module, iter, ctx),
                 &mut scoped_section, "an expression", "a list of expressions", Some(&mut end_pos)
             )?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this,
                 span: InputSpan::from_positions(start_pos, end_pos),
                 value: Literal::Array(scoped_section.into_vec()),
                 parent: ExpressionParent::None,
-                unique_id_in_definition: -1,
+                type_index: -1,
             }).upcast()
         } else if next == Some(TokenKind::Integer) {
             let (literal, span) = consume_integer_literal(&module.source, iter, &mut self.buffer)?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::Integer(LiteralInteger{ unsigned_value: literal, negated: false }),
                 parent: ExpressionParent::None,
-                unique_id_in_definition: -1,
+                type_index: -1,
             }).upcast()
         } else if next == Some(TokenKind::String) {
             let span = consume_string_literal(&module.source, iter, &mut self.buffer)?;
             let interned = ctx.pool.intern(self.buffer.as_bytes());
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::String(interned),
                 parent: ExpressionParent::None,
-                unique_id_in_definition: -1,
+                type_index: -1,
             }).upcast()
         } else if next == Some(TokenKind::Character) {
             let (character, span) = consume_character_literal(&module.source, iter)?;
             ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                 this, span,
                 value: Literal::Character(character),
                 parent: ExpressionParent::None,
-                unique_id_in_definition: -1,
+                type_index: -1,
             }).upcast()
         } else if next == Some(TokenKind::Ident) {
             // May be a variable, a type instantiation or a function call. If we
             // have a single identifier that we cannot find in the type table
             // then we're going to assume that we're dealing with a variable.
             let ident_span = iter.next_span();
             let ident_text = module.source.section_at_span(ident_span);
             let symbol = ctx.symbols.get_symbol_by_name(SymbolScope::Module(module.root_id), ident_text);
             if symbol.is_some() {
                 // The first bit looked like a symbol, so we're going to follow
                 // that all the way through, assume we arrive at some kind of
                 // function call or type instantiation
                 use ParserTypeVariant as PTV;
                 let symbol_scope = SymbolScope::Definition(self.cur_definition);
                 let poly_vars = ctx.heap[self.cur_definition].poly_vars();
                 let parser_type = self.type_parser.consume_parser_type(
                     iter, &ctx.heap, &module.source, &ctx.symbols, poly_vars, self.cur_definition,
                     symbol_scope, true, None
                 )?;
                 debug_assert!(!parser_type.elements.is_empty());
                 match parser_type.elements[0].variant {
                     PTV::Definition(target_definition_id, _) => {
                         let definition = &ctx.heap[target_definition_id];
                         match definition {
                             Definition::Struct(_) => {
                                 // Struct literal
                                 let mut last_token = iter.last_valid_pos();
                                 let mut struct_fields = Vec::new();
                                 consume_comma_separated(
                                     TokenKind::OpenCurly, TokenKind::CloseCurly, &module.source, iter, ctx,
                                     |source, iter, ctx| {
                                         let identifier = consume_ident_interned(source, iter, ctx)?;
                                         consume_token(source, iter, TokenKind::Colon)?;
                                         let value = self.consume_expression(module, iter, ctx)?;
                                         Ok(LiteralStructField{ identifier, value, field_idx: 0 })
                                     },
                                     &mut struct_fields, "a struct field", "a list of struct fields", Some(&mut last_token)
                                 )?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, last_token),
                                     value: Literal::Struct(LiteralStruct{
                                         parser_type,
                                         fields: struct_fields,
                                         definition: target_definition_id,
                                     }),
                                     parent: ExpressionParent::None,
-                                    unique_id_in_definition: -1,
+                                    type_index: -1,
                                 }).upcast()
                             },
                             Definition::Enum(_) => {
                                 // Enum literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, variant.span.end),
                                     value: Literal::Enum(LiteralEnum{
                                         parser_type,
                                         variant,
                                         definition: target_definition_id,
                                         variant_idx: 0
                                     }),
                                     parent: ExpressionParent::None,
-                                    unique_id_in_definition: -1,
+                                    type_index: -1,
                                 }).upcast()
                             },
                             Definition::Union(_) => {
                                 // Union literal: consume the variant
                                 consume_token(&module.source, iter, TokenKind::ColonColon)?;
                                 let variant = consume_ident_interned(&module.source, iter, ctx)?;
                                 // Consume any possible embedded values
                                 let mut end_pos = variant.span.end;
                                 let values = if Some(TokenKind::OpenParen) == iter.next() {
                                     self.consume_expression_list(module, iter, ctx, Some(&mut end_pos))?
                                 } else {
                                     Vec::new()
                                 };
                                 ctx.heap.alloc_literal_expression(|this| LiteralExpression{
                                     this,
                                     span: InputSpan::from_positions(ident_span.begin, end_pos),
                                     value: Literal::Union(LiteralUnion{
                                         parser_type, variant, values,
                                         definition: target_definition_id,
                                         variant_idx: 0,
                                     }),
                                     parent: ExpressionParent::None,
-                                    unique_id_in_definition: -1,
+                                    type_index: -1,
                                 }).upcast()
                             },
                             Definition::Procedure(proc_def) => {
                                 // Check whether it is a builtin function
                                 let procedure_id = proc_def.this;
                                 let method = if proc_def.builtin {
                                     match proc_def.identifier.value.as_bytes() {
                                         KW_FUNC_GET => Method::Get,
                                         KW_FUNC_PUT => Method::Put,
                                         KW_FUNC_FIRES => Method::Fires,
                                         KW_FUNC_CREATE => Method::Create,
                                         KW_FUNC_LENGTH => Method::Length,
                                         KW_FUNC_ASSERT => Method::Assert,
                                         KW_FUNC_PRINT => Method::Print,
                                         _ => unreachable!(),
+                                    }
                                 } else if proc_def.kind == ProcedureKind::Function {
-                                    Method::UserProcedure
+                                    Method::UserFunction
                                 } else {
                                     Method::UserComponent
                                 };
                                 // Function call: consume the arguments
                                 let func_span = parser_type.full_span;
                                 let mut full_span = func_span;
                                 let arguments = self.consume_expression_list(
                                     module, iter, ctx, Some(&mut full_span.end)
                                 )?;
                                 ctx.heap.alloc_call_expression(|this| CallExpression{
                                     this, func_span, full_span, parser_type, method, arguments,
                                     procedure: procedure_id,
                                     parent: ExpressionParent::None,
-                                    unique_id_in_definition: -1,
+                                    type_index: -1,
                                 }).upcast()
+                            }
+                        }
                     },
                     _ => {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, parser_type.full_span, "unexpected type in expression"
                         ))
+                    }
+                }
             } else {
                 // Check for builtin keywords or builtin functions
                 if ident_text == KW_LIT_NULL || ident_text == KW_LIT_TRUE || ident_text == KW_LIT_FALSE {
                     iter.consume();
                     // Parse builtin literal
                     let value = match ident_text {
                         KW_LIT_NULL => Literal::Null,
                         KW_LIT_TRUE => Literal::True,
                         KW_LIT_FALSE => Literal::False,
                         _ => unreachable!(),
                     };
                     ctx.heap.alloc_literal_expression(|this| LiteralExpression {
                         this,
                         span: ident_span,
                         value,
                         parent: ExpressionParent::None,
-                        unique_id_in_definition: -1,
+                        type_index: -1,
                     }).upcast()
                 } else if ident_text == KW_LET {
                     // Binding expression
                     let operator_span = iter.next_span();
                     iter.consume();
                     let bound_to = self.consume_prefix_expression(module, iter, ctx)?;
                     consume_token(&module.source, iter, TokenKind::Equal)?;
                     let bound_from = self.consume_prefix_expression(module, iter, ctx)?;
                     let full_span = InputSpan::from_positions(
                         operator_span.begin, ctx.heap[bound_from].full_span().end,
                     );
                     ctx.heap.alloc_binding_expression(|this| BindingExpression{
                         this, operator_span, full_span, bound_to, bound_from,
                         parent: ExpressionParent::None,
-                        unique_id_in_definition: -1,
+                        type_index: -1,
                     }).upcast()
                 } else if ident_text == KW_CAST {
                     // Casting expression
                     iter.consume();
                     let to_type = if Some(TokenKind::OpenAngle) == iter.next() {
                         let angle_start_pos = iter.next_start_position();
                         iter.consume();
                         let definition_id = self.cur_definition;
                         let poly_vars = ctx.heap[definition_id].poly_vars();
                         self.type_parser.consume_parser_type(
                             iter, &ctx.heap, &module.source, &ctx.symbols,
                             poly_vars, definition_id, SymbolScope::Module(module.root_id),
                             true, Some(angle_start_pos)
                         )?
                     } else {
                         // Automatic casting with inferred target type
                         ParserType{
                             elements: vec![ParserTypeElement{
                                 element_span: ident_span,
                                 variant: ParserTypeVariant::Inferred,
                             }],
                             full_span: ident_span
+                        }
                     };
                     consume_token(&module.source, iter, TokenKind::OpenParen)?;
                     let subject = self.consume_expression(module, iter, ctx)?;
                     let mut full_span = iter.next_span();
                     full_span.begin = to_type.full_span.begin;
                     consume_token(&module.source, iter, TokenKind::CloseParen)?;
                     ctx.heap.alloc_cast_expression(|this| CastExpression{
                         this,
                         cast_span: to_type.full_span,
                         full_span, to_type, subject,
                         parent: ExpressionParent::None,
-                        unique_id_in_definition: -1,
+                        type_index: -1,
                     }).upcast()
                 } else {
                     // Not a builtin literal, but also not a known type. So we
                     // assume it is a variable expression. Although if we do,
                     // then if a programmer mistyped a struct/function name the
                     // error messages will be rather cryptic. For polymorphic
                     // arguments we can't really do anything at all (because it
                     // uses the '<' token). In the other cases we try to provide
                     // a better error message.
                     iter.consume();
                     let next = iter.next();
                     if Some(TokenKind::ColonColon) == next {
                         return Err(ParseError::new_error_str_at_span(&module.source, ident_span, "unknown identifier"));
                     } else if Some(TokenKind::OpenParen) == next {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, ident_span,
                             "unknown identifier, did you mistype a union variant's, component's, or function's name?"
                         ));
                     } else if Some(TokenKind::OpenCurly) == next {
                         return Err(ParseError::new_error_str_at_span(
                             &module.source, ident_span,
                             "unknown identifier, did you mistype a struct type's name?"
                         ))
+                    }
                     let ident_text = ctx.pool.intern(ident_text);
                     let identifier = Identifier { span: ident_span, value: ident_text };
                     ctx.heap.alloc_variable_expression(|this| VariableExpression {
                         this,
                         identifier,
                         declaration: None,
                         used_as_binding_target: false,
                         parent: ExpressionParent::None,
-                        unique_id_in_definition: -1,
+                        type_index: -1,
                     }).upcast()
+                }
+            }
         } else {
             return Err(ParseError::new_error_str_at_pos(
                 &module.source, iter.last_valid_pos(), "expected an expression"
             ));
         };
         Ok(result)
+    }
     //--------------------------------------------------------------------------
     // Expression Utilities
     //--------------------------------------------------------------------------
     #[inline]
     fn consume_generic_binary_expression<
         M: Fn(Option<TokenKind>) -> Option<BinaryOperator>,
         F: Fn(&mut PassDefinitions, &Module, &mut TokenIter, &mut PassCtx) -> Result<ExpressionId, ParseError>
     >(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, match_fn: M, higher_precedence_fn: F
     ) -> Result<ExpressionId, ParseError> {
         let mut result = higher_precedence_fn(self, module, iter, ctx)?;
         while let Some(operation) = match_fn(iter.next()) {
             let operator_span = iter.next_span();
             iter.consume();
             let left = result;
             let right = higher_precedence_fn(self, module, iter, ctx)?;
             let full_span = InputSpan::from_positions(
                 ctx.heap[left].full_span().begin,
                 ctx.heap[right].full_span().end,
             );
             result = ctx.heap.alloc_binary_expression(|this| BinaryExpression{
                 this, operator_span, full_span, left, operation, right,
                 parent: ExpressionParent::None,
-                unique_id_in_definition: -1,
+                type_index: -1,
             }).upcast();
+        }
         Ok(result)
+    }
     #[inline]
     fn consume_expression_list(
         &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx, end_pos: Option<&mut InputPosition>
     ) -> Result<Vec<ExpressionId>, ParseError> {
         let mut section = self.expressions.start_section();
         consume_comma_separated(
             TokenKind::OpenParen, TokenKind::CloseParen, &module.source, iter, ctx,
             |_source, iter, ctx| self.consume_expression(module, iter, ctx),
             &mut section, "an expression", "a list of expressions", end_pos
         )?;
         Ok(section.into_vec())
+    }
+}
 /// Consumes polymorphic variables and throws them on the floor.
 fn consume_polymorphic_vars_spilled(source: &InputSource, iter: &mut TokenIter, _ctx: &mut PassCtx) -> Result<(), ParseError> {
     maybe_consume_comma_separated_spilled(
         TokenKind::OpenAngle, TokenKind::CloseAngle, source, iter, _ctx,
         |source, iter, _ctx| {
             consume_ident(source, iter)?;
             Ok(())
         }, "a polymorphic variable"
     )?;
     Ok(())
+}
 /// Consumes the parameter list to functions/components
 fn consume_parameter_list(
     parser: &mut ParserTypeParser, source: &InputSource, iter: &mut TokenIter,
     ctx: &mut PassCtx, target: &mut ScopedSection<VariableId>,
     scope: SymbolScope, definition_id: DefinitionId
 ) -> Result<(), ParseError> {
     consume_comma_separated(
         TokenKind::OpenParen, TokenKind::CloseParen, source, iter, ctx,
         |source, iter, ctx| {
             let poly_vars = ctx.heap[definition_id].poly_vars(); // Rust being rust, multiple lookups
             let parser_type = parser.consume_parser_type(
                 iter, &ctx.heap, source, &ctx.symbols, poly_vars, definition_id,
                 scope, false, None
             )?;
             let identifier = consume_ident_interned(source, iter, ctx)?;
             let parameter_id = ctx.heap.alloc_variable(|this| Variable{
                 this,
                 kind: VariableKind::Parameter,
                 parser_type,
                 identifier,
                 relative_pos_in_parent: 0,
                 unique_id_in_scope: -1,
             });
             Ok(parameter_id)
         },
         target, "a parameter", "a parameter list", None
+    )
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_rewriting.rs

➞

Show inline comments

@@ @@ -215,328 +215,327 @@ impl Visitor for PassRewriting { @@
+        {
             let mut total_port_index = 0;
             for case_index in 0..total_num_cases {
                 let case = &ctx.heap[id].cases[case_index];
                 let case_num_ports = case.involved_ports.len();
                 for case_port_index in 0..case_num_ports {
                     // Arguments to runtime call
                     let port_variable_id = locals[total_port_index]; // so far this variable contains the temporary variables for the port expressions
                     let case_index_expr_id = create_ast_literal_integer_expr(ctx, case_index as u64);
                     let port_index_expr_id = create_ast_literal_integer_expr(ctx, case_port_index as u64);
                     let port_variable_expr_id = create_ast_variable_expr(ctx, port_variable_id);
                     let runtime_call_arguments = vec![
                         case_index_expr_id.upcast(),
                         port_index_expr_id.upcast(),
                         port_variable_expr_id.upcast()
                     ];
                     // Create runtime call, then store it
                     let runtime_call_expr_id = create_ast_call_expr(ctx, Method::SelectRegisterCasePort, &mut self.expression_buffer, runtime_call_arguments);
                     let runtime_call_stmt_id = create_ast_expression_stmt(ctx, runtime_call_expr_id.upcast());
                     transformed_stmts.push(runtime_call_stmt_id.upcast());
                     total_port_index += 1;
+                }
+            }
+        }
         // Create the variable that will hold the result of a completed select
         // block. Then create the runtime call that will produce this result
         let select_variable_id = create_ast_variable(ctx, outer_scope_id);
         locals.push(select_variable_id);
+        {
             let runtime_call_expr_id = create_ast_call_expr(ctx, Method::SelectWait, &mut self.expression_buffer, Vec::new());
             let variable_stmt_id = create_ast_variable_declaration_stmt(ctx, select_variable_id, runtime_call_expr_id.upcast());
             transformed_stmts.push(variable_stmt_id.upcast().upcast());
+        }
         call_id_section.forget();
         expr_id_section.forget();
         // Now we transform each of the select block case's guard and code into
         // a chained if-else statement.
         if total_num_cases > 0 {
             let (if_stmt_id, end_if_stmt_id) = transform_select_case_code(ctx, id, 0, select_variable_id);
             let first_end_if_stmt = &mut ctx.heap[end_if_stmt_id];
             first_end_if_stmt.next = outer_end_block_id.upcast();
             let mut last_if_stmt_id = if_stmt_id;
             let mut last_end_if_stmt_id = end_if_stmt_id;
             transformed_stmts.push(last_if_stmt_id.upcast());
             for case_index in 1..total_num_cases {
                 let (if_stmt_id, end_if_stmt_id) = transform_select_case_code(ctx, id, case_index, select_variable_id);
                 let false_case_scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::If(last_if_stmt_id, false)));
                 set_ast_if_statement_false_body(ctx, last_if_stmt_id, last_end_if_stmt_id, IfStatementCase{ body: if_stmt_id.upcast(), scope: false_case_scope_id });
                 let end_if_stmt = &mut ctx.heap[end_if_stmt_id];
                 end_if_stmt.next = last_end_if_stmt_id.upcast();
                 last_if_stmt_id = if_stmt_id;
                 last_end_if_stmt_id = end_if_stmt_id;
+            }
+        }
         // Final steps: set the statements of the replacement block statement,
         // and link all of those statements together
         let mut last_stmt_id = transformed_stmts[0];
         for stmt_id in transformed_stmts.iter().skip(1).copied() {
             set_ast_statement_next(ctx, last_stmt_id, stmt_id);
             last_stmt_id = stmt_id;
+        }
         let outer_block_stmt = &mut ctx.heap[outer_block_id];
         outer_block_stmt.statements = transformed_stmts;
         return Ok(())
+    }
+}
 impl PassRewriting {
     fn create_runtime_call_statement(&self, ctx: &mut Ctx, method: Method, arguments: Vec<ExpressionId>) -> (CallExpressionId, ExpressionStatementId) {
         let call_expr_id = ctx.heap.alloc_call_expression(|this| CallExpression{
             this,
             func_span: InputSpan::new(),
             full_span: InputSpan::new(),
             parser_type: ParserType{
                 elements: Vec::new(),
                 full_span: InputSpan::new(),
             },
             method,
             arguments,
             procedure: ProcedureDefinitionId::new_invalid(),
             parent: ExpressionParent::None,
             unique_id_in_definition: -1,
         });
         let call_stmt_id = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
             this,
             span: InputSpan::new(),
             expression: call_expr_id.upcast(),
             next: StatementId::new_invalid(),
         });
         let call_expr = &mut ctx.heap[call_expr_id];
         call_expr.parent = ExpressionParent::ExpressionStmt(call_stmt_id);
         return (call_expr_id, call_stmt_id);
+    }
+}
 // -----------------------------------------------------------------------------
 // Utilities to create compiler-generated AST nodes
 // -----------------------------------------------------------------------------
 fn create_ast_variable(ctx: &mut Ctx, scope_id: ScopeId) -> VariableId {
     let variable_id = ctx.heap.alloc_variable(|this| Variable{
         this,
         kind: VariableKind::Local,
         parser_type: ParserType{
             elements: Vec::new(),
             full_span: InputSpan::new(),
         },
         identifier: Identifier::new_empty(InputSpan::new()),
         relative_pos_in_parent: -1,
         unique_id_in_scope: -1,
     });
     let scope = &mut ctx.heap[scope_id];
     scope.variables.push(variable_id);
     return variable_id;
+}
 fn create_ast_variable_expr(ctx: &mut Ctx, variable_id: VariableId) -> VariableExpressionId {
     return ctx.heap.alloc_variable_expression(|this| VariableExpression{
         this,
         identifier: Identifier::new_empty(InputSpan::new()),
         declaration: Some(variable_id),
         used_as_binding_target: false,
         parent: ExpressionParent::None,
-        unique_id_in_definition: -1
+        type_index: -1
     });
+}
 fn create_ast_call_expr(ctx: &mut Ctx, method: Method, buffer: &mut ScopedBuffer<ExpressionId>, arguments: Vec<ExpressionId>) -> CallExpressionId {
     let expression_ids = buffer.start_section_initialized(&arguments);
     let call_expression_id = ctx.heap.alloc_call_expression(|this| CallExpression{
         this,
         func_span: InputSpan::new(),
         full_span: InputSpan::new(),
         parser_type: ParserType{
             elements: Vec::new(),
             full_span: InputSpan::new(),
         },
         method,
         arguments,
         procedure: ProcedureDefinitionId::new_invalid(),
         parent: ExpressionParent::None,
-        unique_id_in_definition: -1,
+        type_index: -1,
     });
     for argument_index in 0..expression_ids.len() {
         let argument_id = expression_ids[argument_index];
         let argument_expr = &mut ctx.heap[argument_id];
         *argument_expr.parent_mut() = ExpressionParent::Expression(call_expression_id.upcast(), argument_index as u32);
+    }
     return call_expression_id;
+}
 fn create_ast_literal_integer_expr(ctx: &mut Ctx, unsigned_value: u64) -> LiteralExpressionId {
     return ctx.heap.alloc_literal_expression(|this| LiteralExpression{
         this,
         span: InputSpan::new(),
         value: Literal::Integer(LiteralInteger{
             unsigned_value,
             negated: false,
         }),
         parent: ExpressionParent::None,
-        unique_id_in_definition: -1
+        type_index: -1
     });
+}
 fn create_ast_equality_comparison_expr(ctx: &mut Ctx, variable_id: VariableId, value: u64) -> BinaryExpressionId {
     let var_expr_id = create_ast_variable_expr(ctx, variable_id);
     let int_expr_id = create_ast_literal_integer_expr(ctx, value);
     let cmp_expr_id = ctx.heap.alloc_binary_expression(|this| BinaryExpression{
         this,
         operator_span: InputSpan::new(),
         full_span: InputSpan::new(),
         left: var_expr_id.upcast(),
         operation: BinaryOperator::Equality,
         right: int_expr_id.upcast(),
         parent: ExpressionParent::None,
-        unique_id_in_definition: -1,
+        type_index: -1,
     });
     let var_expr = &mut ctx.heap[var_expr_id];
     var_expr.parent = ExpressionParent::Expression(cmp_expr_id.upcast(), 0);
     let int_expr = &mut ctx.heap[int_expr_id];
     int_expr.parent = ExpressionParent::Expression(cmp_expr_id.upcast(), 1);
     return cmp_expr_id;
+}
 fn create_ast_expression_stmt(ctx: &mut Ctx, expression_id: ExpressionId) -> ExpressionStatementId {
     let statement_id = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{
         this,
         span: InputSpan::new(),
         expression: expression_id,
         next: StatementId::new_invalid(),
     });
     let expression = &mut ctx.heap[expression_id];
     *expression.parent_mut() = ExpressionParent::ExpressionStmt(statement_id);
     return statement_id;
+}
 fn create_ast_variable_declaration_stmt(ctx: &mut Ctx, variable_id: VariableId, initial_value_expr_id: ExpressionId) -> MemoryStatementId {
     // Create the assignment expression, assigning the initial value to the variable
     let variable_expr_id = create_ast_variable_expr(ctx, variable_id);
     let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{
         this,
         operator_span: InputSpan::new(),
         full_span: InputSpan::new(),
         left: variable_expr_id.upcast(),
         operation: AssignmentOperator::Set,
         right: initial_value_expr_id,
         parent: ExpressionParent::None,
-        unique_id_in_definition: -1,
+        type_index: -1,
     });
     // Create the memory statement
     let memory_stmt_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{
         this,
         span: InputSpan::new(),
         variable: variable_id,
         initial_expr: assignment_expr_id,
         next: StatementId::new_invalid(),
     });
     // Set all parents which we can access
     let variable_expr = &mut ctx.heap[variable_expr_id];
     variable_expr.parent = ExpressionParent::Expression(assignment_expr_id.upcast(), 0);
     let value_expr = &mut ctx.heap[initial_value_expr_id];
     *value_expr.parent_mut() = ExpressionParent::Expression(assignment_expr_id.upcast(), 1);
     let assignment_expr = &mut ctx.heap[assignment_expr_id];
     assignment_expr.parent = ExpressionParent::Memory(memory_stmt_id);
     return memory_stmt_id;
+}
 fn create_ast_block_stmt(ctx: &mut Ctx, statements: Vec<StatementId>) -> (BlockStatementId, EndBlockStatementId, ScopeId) {
     let block_stmt_id = ctx.heap.alloc_block_statement(|this| BlockStatement{
         this,
         span: InputSpan::new(),
         statements,
         end_block: EndBlockStatementId::new_invalid(),
         scope: ScopeId::new_invalid(),
         next: StatementId::new_invalid(),
     });
     let end_block_stmt_id = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{
         this,
         start_block: block_stmt_id,
         next: StatementId::new_invalid(),
     });
     let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Block(block_stmt_id)));
     let block_stmt = &mut ctx.heap[block_stmt_id];
     block_stmt.end_block = end_block_stmt_id;
     block_stmt.scope = scope_id;
     return (block_stmt_id, end_block_stmt_id, scope_id);
+}
 fn create_ast_if_stmt(ctx: &mut Ctx, condition_expression_id: ExpressionId, true_case: IfStatementCase, false_case: Option<IfStatementCase>) -> (IfStatementId, EndIfStatementId) {
     // Create if statement and the end-if statement
     let if_stmt_id = ctx.heap.alloc_if_statement(|this| IfStatement{
         this,
         span: InputSpan::new(),
         test: condition_expression_id,
         true_case,
         false_case,
         end_if: EndIfStatementId::new_invalid()
     });
     let end_if_stmt_id = ctx.heap.alloc_end_if_statement(|this| EndIfStatement{
         this,
         start_if: if_stmt_id,
         next: StatementId::new_invalid(),
     });
     // Link the statements up as much as we can
     let if_stmt = &mut ctx.heap[if_stmt_id];
     if_stmt.end_if = end_if_stmt_id;
     let condition_expr = &mut ctx.heap[condition_expression_id];
     *condition_expr.parent_mut() = ExpressionParent::If(if_stmt_id);
     return (if_stmt_id, end_if_stmt_id);
+}
 /// Sets the false body for a given
 fn set_ast_if_statement_false_body(ctx: &mut Ctx, if_statement_id: IfStatementId, end_if_statement_id: EndIfStatementId, false_case: IfStatementCase) {
     // Point if-statement to "false body"
     let if_stmt = &mut ctx.heap[if_statement_id];
     debug_assert!(if_stmt.false_case.is_none()); // simplifies logic, not necessary
     if_stmt.false_case = Some(false_case);
     // Point end of false body to the end of the if statement
     set_ast_statement_next(ctx, false_case.body, end_if_statement_id.upcast());
+}
 /// Sets the specified AST statement's control flow such that it will be
 /// followed by the target statement. This may seem obvious, but may imply that
 /// a statement associated with, but different from, the source statement is
 /// modified.
 fn set_ast_statement_next(ctx: &mut Ctx, source_stmt_id: StatementId, target_stmt_id: StatementId) {
     let source_stmt = &mut ctx.heap[source_stmt_id];
     match source_stmt {
         Statement::Block(stmt) => {
             let end_id = stmt.end_block;
             ctx.heap[end_id].next = target_stmt_id
         },

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -724,514 +724,536 @@ impl InferenceType { @@
         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
+}
 // -----------------------------------------------------------------------------
 // PassTyping - Public Interface
 // -----------------------------------------------------------------------------
 type InferNodeIndex = usize;
 type PolyDataIndex = isize;
 type VarDataIndex = usize;
 pub(crate) struct ResolveQueueElement {
     // Note that using the `definition_id` and the `monomorph_idx` one may
     // query the type table for the full procedure type, thereby retrieving
     // the polymorphic arguments to the procedure.
     pub(crate) root_id: RootId,
     pub(crate) definition_id: DefinitionId,
     pub(crate) reserved_type_id: TypeId,
     pub(crate) reserved_monomorph_index: u32,
+}
 pub(crate) type ResolveQueue = Vec<ResolveQueueElement>;
 struct InferenceNode {
     expr_type: InferenceType,       // result type from expression
     expr_id: ExpressionId,          // expression that is evaluated
     inference_rule: InferenceRule,
     parent_index: Option<InferNodeIndex>,
     field_or_monomorph_index: i32,    // index of field
     poly_data_index: PolyDataIndex,            // index of extra data needed for inference
     type_id: TypeId,                // when applicable indexes into type table
     // filled in during type inference
     expr_type: InferenceType,               // result type from expression
     expr_id: ExpressionId,                  // expression that is evaluated
     inference_rule: InferenceRule,          // rule used to infer node type
     parent_index: Option<InferNodeIndex>,   // parent of inference node
     field_index: i32,                       // index of struct field or tuple member
     poly_data_index: PolyDataIndex,         // index to inference data for polymorphic types
     // filled in once type inference is done
     info_type_id: TypeId,
     info_variant: ExpressionInfoVariant,
+}
 impl InferenceNode {
     #[inline]
     fn as_expression_info(&self) -> ExpressionInfo {
         return ExpressionInfo {
             type_id: self.info_type_id,
             variant: self.info_variant
+        }
+    }
+}
 /// Inferencing rule to apply. Some of these are reasonably generic. Other ones
 /// require so much custom logic that we'll not try to come up with an
 /// abstraction.
 enum InferenceRule {
     Noop,
     MonoTemplate(InferenceRuleTemplate),
     BiEqual(InferenceRuleBiEqual),
     TriEqualArgs(InferenceRuleTriEqualArgs),
     TriEqualAll(InferenceRuleTriEqualAll),
     Concatenate(InferenceRuleTwoArgs),
     IndexingExpr(InferenceRuleIndexingExpr),
     SlicingExpr(InferenceRuleSlicingExpr),
     SelectStructField(InferenceRuleSelectStructField),
     SelectTupleMember(InferenceRuleSelectTupleMember),
     LiteralStruct(InferenceRuleLiteralStruct),
     LiteralEnum,
     LiteralUnion(InferenceRuleLiteralUnion),
     LiteralArray(InferenceRuleLiteralArray),
     LiteralTuple(InferenceRuleLiteralTuple),
     CastExpr(InferenceRuleCastExpr),
     CallExpr(InferenceRuleCallExpr),
     VariableExpr(InferenceRuleVariableExpr),
+}
 impl InferenceRule {
     union_cast_method_impl!(as_mono_template, InferenceRuleTemplate, InferenceRule::MonoTemplate);
     union_cast_method_impl!(as_bi_equal, InferenceRuleBiEqual, InferenceRule::BiEqual);
     union_cast_method_impl!(as_tri_equal_args, InferenceRuleTriEqualArgs, InferenceRule::TriEqualArgs);
     union_cast_method_impl!(as_tri_equal_all, InferenceRuleTriEqualAll, InferenceRule::TriEqualAll);
     union_cast_method_impl!(as_concatenate, InferenceRuleTwoArgs, InferenceRule::Concatenate);
     union_cast_method_impl!(as_indexing_expr, InferenceRuleIndexingExpr, InferenceRule::IndexingExpr);
     union_cast_method_impl!(as_slicing_expr, InferenceRuleSlicingExpr, InferenceRule::SlicingExpr);
     union_cast_method_impl!(as_select_struct_field, InferenceRuleSelectStructField, InferenceRule::SelectStructField);
     union_cast_method_impl!(as_select_tuple_member, InferenceRuleSelectTupleMember, InferenceRule::SelectTupleMember);
     union_cast_method_impl!(as_literal_struct, InferenceRuleLiteralStruct, InferenceRule::LiteralStruct);
     union_cast_method_impl!(as_literal_union, InferenceRuleLiteralUnion, InferenceRule::LiteralUnion);
     union_cast_method_impl!(as_literal_array, InferenceRuleLiteralArray, InferenceRule::LiteralArray);
     union_cast_method_impl!(as_literal_tuple, InferenceRuleLiteralTuple, InferenceRule::LiteralTuple);
     union_cast_method_impl!(as_cast_expr, InferenceRuleCastExpr, InferenceRule::CastExpr);
     union_cast_method_impl!(as_call_expr, InferenceRuleCallExpr, InferenceRule::CallExpr);
     union_cast_method_impl!(as_variable_expr, InferenceRuleVariableExpr, InferenceRule::VariableExpr);
+}
 // Note: InferenceRuleTemplate is `Copy`, so don't add dynamically allocated
 // members in the future (or review places where this struct is copied)
 #[derive(Clone, Copy)]
 struct InferenceRuleTemplate {
     template: &'static [InferenceTypePart],
     application: InferenceRuleTemplateApplication,
+}
 impl InferenceRuleTemplate {
     fn new_none() -> Self {
         return Self{
             template: &[],
             application: InferenceRuleTemplateApplication::None,
         };
+    }
     fn new_forced(template: &'static [InferenceTypePart]) -> Self {
         return Self{
             template,
             application: InferenceRuleTemplateApplication::Forced,
         };
+    }
     fn new_template(template: &'static [InferenceTypePart]) -> Self {
         return Self{
             template,
             application: InferenceRuleTemplateApplication::Template,
+        }
+    }
+}
 #[derive(Clone, Copy)]
 enum InferenceRuleTemplateApplication {
     None, // do not apply template, silly, but saves some bytes
     Forced,
     Template,
+}
 /// Type equality applied to 'self' and the argument. An optional template will
 /// be applied to 'self' first. Example: "bitwise not"
 struct InferenceRuleBiEqual {
     template: InferenceRuleTemplate,
     argument_index: InferNodeIndex,
+}
 /// Type equality applied to two arguments. Template can be applied to 'self'
 /// (generally forced, since this rule does not apply a type equality constraint
 /// to 'self') and the two arguments. Example: "equality operator"
 struct InferenceRuleTriEqualArgs {
     argument_template: InferenceRuleTemplate,
     result_template: InferenceRuleTemplate,
     argument1_index: InferNodeIndex,
     argument2_index: InferNodeIndex,
+}
 /// Type equality applied to 'self' and two arguments. Template may be
 /// optionally applied to 'self'. Example: "addition operator"
 struct InferenceRuleTriEqualAll {
     template: InferenceRuleTemplate,
     argument1_index: InferNodeIndex,
     argument2_index: InferNodeIndex,
+}
 /// Information for an inference rule that is applied to 'self' and two
 /// arguments, see `InferenceRule` for its meaning.
 struct InferenceRuleTwoArgs {
     argument1_index: InferNodeIndex,
     argument2_index: InferNodeIndex,
+}
 struct InferenceRuleIndexingExpr {
     subject_index: InferNodeIndex,
     index_index: InferNodeIndex,
+}
 struct InferenceRuleSlicingExpr {
     subject_index: InferNodeIndex,
     from_index: InferNodeIndex,
     to_index: InferNodeIndex,
+}
 struct InferenceRuleSelectStructField {
     subject_index: InferNodeIndex,
     selected_field: Identifier,
+}
 struct InferenceRuleSelectTupleMember {
     subject_index: InferNodeIndex,
     selected_index: u64,
+}
 struct InferenceRuleLiteralStruct {
     element_indices: Vec<InferNodeIndex>,
+}
 struct InferenceRuleLiteralUnion {
     element_indices: Vec<InferNodeIndex>
+}
 struct InferenceRuleLiteralArray {
     element_indices: Vec<InferNodeIndex>
+}
 struct InferenceRuleLiteralTuple {
     element_indices: Vec<InferNodeIndex>
+}
 struct InferenceRuleCastExpr {
     subject_index: InferNodeIndex,
+}
 struct InferenceRuleCallExpr {
     argument_indices: Vec<InferNodeIndex>
+}
 /// Data associated with a variable expression: an expression that reads the
 /// value from a variable.
 struct InferenceRuleVariableExpr {
     var_data_index: VarDataIndex, // shared variable information
+}
 /// 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_type_id: TypeId,
     reserved_monomorph_index: u32,
     procedure_id: ProcedureDefinitionId,
     procedure_kind: ProcedureKind,
     poly_vars: Vec<ConcreteType>,
     // Temporary variables during construction of inference rulesr
     parent_index: Option<InferNodeIndex>,
     // Buffers for iteration over various types
     var_buffer: ScopedBuffer<VariableId>,
     expr_buffer: ScopedBuffer<ExpressionId>,
     stmt_buffer: ScopedBuffer<StatementId>,
     bool_buffer: ScopedBuffer<bool>,
     index_buffer: ScopedBuffer<usize>,
     poly_progress_buffer: ScopedBuffer<u32>,
     // Mapping from parser type to inferred type. We attempt to continue to
     // specify these types until we're stuck or we've fully determined the type.
     infer_nodes: Vec<InferenceNode>,                     // will be transferred to type table at end
     poly_data: Vec<PolyData>,       // data for polymorph inference
     var_data: Vec<VarData>,
     // Keeping track of which expressions need to be reinferred because the
     // expressions they're linked to made progression on an associated type
     node_queued: DequeSet<InferNodeIndex>,
+}
 /// Generic struct that is used to store inferred types associated with
 /// polymorphic types.
 struct PolyData {
     first_rule_application: bool,
     definition_id: DefinitionId, // the definition, only used for user feedback
     /// Inferred types of the polymorphic variables as they are written down
     /// at the type's definition.
     poly_vars: Vec<InferenceType>,
     expr_types: PolyDataTypes,
+}
 // silly structure, just so we can use `PolyDataTypeIndex` ergonomically while
 // making sure we're still capable of borrowing from `poly_vars`.
 struct PolyDataTypes {
     /// Inferred types of associated types (e.g. struct fields, tuple members,
     /// function arguments). These types may depend on the polymorphic variables
     /// defined above.
     associated: Vec<InferenceType>,
     /// Inferred "returned" type (e.g. if a struct field is selected, then this
     /// contains the type of the selected field, for a function call it contains
     /// the return type). May depend on the polymorphic variables defined above.
     returned: InferenceType,
+}
 #[derive(Clone, Copy)]
 enum PolyDataTypeIndex {
     Associated(usize), // indexes into `PolyData.associated`
     Returned,
+}
 impl PolyDataTypes {
     fn get_type(&self, index: PolyDataTypeIndex) -> &InferenceType {
         match index {
             PolyDataTypeIndex::Associated(index) => return &self.associated[index],
             PolyDataTypeIndex::Returned => return &self.returned,
+        }
+    }
     fn get_type_mut(&mut self, index: PolyDataTypeIndex) -> &mut InferenceType {
         match index {
             PolyDataTypeIndex::Associated(index) => return &mut self.associated[index],
             PolyDataTypeIndex::Returned => return &mut self.returned,
+        }
+    }
+}
 struct VarData {
     var_id: VariableId,
     var_type: InferenceType,
     used_at: Vec<InferNodeIndex>, // of variable expressions
     linked_var: Option<VarDataIndex>,
+}
 impl PassTyping {
     pub(crate) fn new() -> Self {
         PassTyping {
             reserved_type_id: TypeId::new_invalid(),
             reserved_monomorph_index: u32::MAX,
             procedure_id: ProcedureDefinitionId::new_invalid(),
             procedure_kind: ProcedureKind::Function,
             poly_vars: Vec::new(),
             parent_index: None,
             var_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),
             expr_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),
             stmt_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),
             bool_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
             index_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
             poly_progress_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
             infer_nodes: Vec::with_capacity(BUFFER_INIT_CAP_LARGE),
             poly_data: Vec::with_capacity(BUFFER_INIT_CAP_SMALL),
             var_data: Vec::with_capacity(BUFFER_INIT_CAP_SMALL),
             node_queued: DequeSet::new(),
+        }
+    }
     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 first_concrete_part = match definition {
+            let first_concrete_part_and_procedure_id = match definition {
                 Definition::Procedure(definition) => {
                     if definition.poly_vars.is_empty() {
                         if definition.kind == ProcedureKind::Function {
                             Some(ConcreteTypePart::Function(definition.this, 0))
+                            Some((ConcreteTypePart::Function(definition.this, 0), definition.this))
                         } else {
                             Some(ConcreteTypePart::Component(definition.this, 0))
+                            Some((ConcreteTypePart::Component(definition.this, 0), definition.this))
+                        }
                     } else {
                         None
+                    }
+                }
                 Definition::Enum(_) | Definition::Struct(_) | Definition::Union(_) => None,
             };
             if let Some(first_concrete_part) = first_concrete_part {
             if let Some((first_concrete_part, procedure_id)) = first_concrete_part_and_procedure_id {
                 let procedure = &mut ctx.heap[procedure_id];
                 let monomorph_index = procedure.monomorphs.len() as u32;
                 procedure.monomorphs.push(ProcedureDefinitionMonomorph::new_invalid());
                 let concrete_type = ConcreteType{ parts: vec![first_concrete_part] };
                 let type_id = ctx.types.reserve_procedure_monomorph_type_id(definition_id, concrete_type);
+                let type_id = ctx.types.reserve_procedure_monomorph_type_id(definition_id, concrete_type, monomorph_index);
                 queue.push(ResolveQueueElement{
                     root_id,
                     definition_id: *definition_id,
                     reserved_type_id: type_id,
                     reserved_monomorph_index: monomorph_index,
                 })
+            }
+        }
+    }
     pub(crate) fn handle_module_definition(
         &mut self, ctx: &mut Ctx, queue: &mut ResolveQueue, element: ResolveQueueElement
     ) -> VisitorResult {
         self.reset();
         debug_assert_eq!(ctx.module().root_id, element.root_id);
         debug_assert!(self.poly_vars.is_empty());
         // Prepare for visiting the definition
         self.reserved_type_id = element.reserved_type_id;
         self.reserved_monomorph_index = element.reserved_monomorph_index;
         let proc_base = ctx.types.get_base_definition(&element.definition_id).unwrap();
         if proc_base.is_polymorph {
             let monomorph = ctx.types.get_monomorph(element.reserved_type_id);
             for poly_arg in monomorph.concrete_type.embedded_iter(0) {
                 self.poly_vars.push(ConcreteType{ parts: Vec::from(poly_arg) });
+            }
+        }
         // Visit the definition, setting up the type resolving process, then
         // (attempt to) resolve all types
         self.visit_definition(ctx, element.definition_id)?;
         self.resolve_types(ctx, queue)?;
         Ok(())
+    }
     fn reset(&mut self) {
         self.reserved_type_id = TypeId::new_invalid();
         self.procedure_id = ProcedureDefinitionId::new_invalid();
         self.procedure_kind = ProcedureKind::Function;
         self.poly_vars.clear();
         self.parent_index = None;
         self.infer_nodes.clear();
         self.poly_data.clear();
         self.var_data.clear();
         self.node_queued.clear();
+    }
+}
 // -----------------------------------------------------------------------------
 // PassTyping - Visitor-like implementation
 // -----------------------------------------------------------------------------
 type VisitorResult = Result<(), ParseError>;
 type VisitExprResult = Result<InferNodeIndex, ParseError>;
 impl PassTyping {
     // Definitions
     fn visit_definition(&mut self, ctx: &mut Ctx, id: DefinitionId) -> VisitorResult {
         return visitor_recursive_definition_impl!(self, &ctx.heap[id], ctx);
+    }
     fn visit_enum_definition(&mut self, _: &mut Ctx, _: EnumDefinitionId) -> VisitorResult { return Ok(()) }
     fn visit_struct_definition(&mut self, _: &mut Ctx, _: StructDefinitionId) -> VisitorResult { return Ok(()) }
     fn visit_union_definition(&mut self, _: &mut Ctx, _: UnionDefinitionId) -> VisitorResult { return Ok(()) }
     fn visit_procedure_definition(&mut self, ctx: &mut Ctx, id: ProcedureDefinitionId) -> VisitorResult {
         let procedure_def = &ctx.heap[id];
         self.procedure_id = id;
         self.procedure_kind = procedure_def.kind;
         let body_id = procedure_def.body;
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting procedure: '{}' (id: {}, kind: {:?})", procedure_def.identifier.value.as_str(), id.0.index, procedure_def.kind);
         debug_log!("{}", "-".repeat(50));
         // Visit parameters
         let section = self.var_buffer.start_section_initialized(procedure_def.parameters.as_slice());
         for param_id in section.iter_copied() {
             let param = &ctx.heap[param_id];
             let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);
             debug_assert!(var_type.is_done, "expected function arguments to be concrete types");
             self.var_data.push(VarData{
                 var_id: param_id,
                 var_type,
                 used_at: Vec::new(),
                 linked_var: None
             })
+        }
         section.forget();
         // Visit all of the expressions within the body
         self.parent_index = None;
         return self.visit_block_stmt(ctx, body_id);
+    }
     // Statements
     fn visit_stmt(&mut self, ctx: &mut Ctx, id: StatementId) -> VisitorResult {
         return visitor_recursive_statement_impl!(self, &ctx.heap[id], ctx, Ok(()));
+    }
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         // Transfer statements for traversal
         let block = &ctx.heap[id];
         let section = self.stmt_buffer.start_section_initialized(block.statements.as_slice());
         for stmt_id in section.iter_copied() {
             self.visit_stmt(ctx, stmt_id)?;
+        }
         section.forget();
         Ok(())
@@ @@ -1732,470 +1754,461 @@ impl PassTyping { @@
                 // May carry subexpressions and polymorphic arguments
                 let expr_ids = self.expr_buffer.start_section_initialized(literal.values.as_slice());
                 let poly_data_index = self.insert_initial_union_polymorph_data(ctx, id);
                 let mut expr_indices = self.index_buffer.start_section();
                 for expr_id in expr_ids.iter_copied() {
                     let expr_index = self.visit_expr(ctx, expr_id)?;
                     expr_indices.push(expr_index);
+                }
                 expr_ids.forget();
                 let element_indices = expr_indices.into_vec();
                 let node = &mut self.infer_nodes[self_index];
                 node.poly_data_index = poly_data_index;
                 node.inference_rule = InferenceRule::LiteralUnion(InferenceRuleLiteralUnion{
                     element_indices,
                 });
             },
             Literal::Array(expressions) => {
                 let expr_ids = self.expr_buffer.start_section_initialized(expressions.as_slice());
                 let mut expr_indices = self.index_buffer.start_section();
                 for expr_id in expr_ids.iter_copied() {
                     let expr_index = self.visit_expr(ctx, expr_id)?;
                     expr_indices.push(expr_index);
+                }
                 expr_ids.forget();
                 let element_indices = expr_indices.into_vec();
                 let node = &mut self.infer_nodes[self_index];
                 node.inference_rule = InferenceRule::LiteralArray(InferenceRuleLiteralArray{
                     element_indices,
                 });
             },
             Literal::Tuple(expressions) => {
                 let expr_ids = self.expr_buffer.start_section_initialized(expressions.as_slice());
                 let mut expr_indices = self.index_buffer.start_section();
                 for expr_id in expr_ids.iter_copied() {
                     let expr_index = self.visit_expr(ctx, expr_id)?;
                     expr_indices.push(expr_index);
+                }
                 expr_ids.forget();
                 let element_indices = expr_indices.into_vec();
                 let node = &mut self.infer_nodes[self_index];
                 node.inference_rule = InferenceRule::LiteralTuple(InferenceRuleLiteralTuple{
                     element_indices,
                 })
+            }
+        }
         self.parent_index = old_parent;
         self.progress_inference_rule(ctx, self_index)?;
         return Ok(self_index);
+    }
     fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitExprResult {
         let upcast_id = id.upcast();
         let self_index = self.insert_initial_inference_node(ctx, upcast_id)?;
         let cast_expr = &ctx.heap[id];
         let subject_expr_id = cast_expr.subject;
         let old_parent = self.parent_index.replace(self_index);
         let subject_index = self.visit_expr(ctx, subject_expr_id)?;
         let node = &mut self.infer_nodes[self_index];
         node.inference_rule = InferenceRule::CastExpr(InferenceRuleCastExpr{
             subject_index,
         });
         self.parent_index = old_parent;
         // The cast expression is a bit special at this point: the progression
         // function simply makes sure input/output types are compatible. But if
         // the programmer explicitly specified the output type, then we can
         // already perform that inference rule here.
+        {
             let cast_expr = &ctx.heap[id];
             let specified_type = self.determine_inference_type_from_parser_type_elements(&cast_expr.to_type.elements, true);
             let _progress = self.apply_template_constraint(ctx, self_index, &specified_type.parts)?;
+        }
         self.progress_inference_rule_cast_expr(ctx, self_index)?;
         return Ok(self_index);
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitExprResult {
         let upcast_id = id.upcast();
         let self_index = self.insert_initial_inference_node(ctx, upcast_id)?;
         let extra_index = self.insert_initial_call_polymorph_data(ctx, id);
         // By default we set the polymorph idx for calls to 0. If the call
         // refers to a non-polymorphic function, then it will be "monomorphed"
         // once, hence we end up pointing to the correct instance.
-        self.infer_nodes[self_index].field_or_monomorph_index = 0;
+        self.infer_nodes[self_index].field_index = 0;
         // Visit all arguments
         let old_parent = self.parent_index.replace(self_index);
         let call_expr = &ctx.heap[id];
         let expr_ids = self.expr_buffer.start_section_initialized(call_expr.arguments.as_slice());
         let mut expr_indices = self.index_buffer.start_section();
         for arg_expr_id in expr_ids.iter_copied() {
             let expr_index = self.visit_expr(ctx, arg_expr_id)?;
             expr_indices.push(expr_index);
+        }
         expr_ids.forget();
         let argument_indices = expr_indices.into_vec();
         let node = &mut self.infer_nodes[self_index];
         node.poly_data_index = extra_index;
         node.inference_rule = InferenceRule::CallExpr(InferenceRuleCallExpr{
             argument_indices,
         });
         self.parent_index = old_parent;
         self.progress_inference_rule_call_expr(ctx, self_index)?;
         return Ok(self_index);
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitExprResult {
         let upcast_id = id.upcast();
         let self_index = self.insert_initial_inference_node(ctx, upcast_id)?;
         let var_expr = &ctx.heap[id];
         debug_assert!(var_expr.declaration.is_some());
         let old_parent = self.parent_index.replace(self_index);
         let declaration = &ctx.heap[var_expr.declaration.unwrap()];
         let mut var_data_index = None;
         for (index, var_data) in self.var_data.iter().enumerate() {
             if var_data.var_id == declaration.this {
                 var_data_index = Some(index);
                 break;
+            }
+        }
         let var_data_index = if let Some(var_data_index) = var_data_index {
             let var_data = &mut self.var_data[var_data_index];
             var_data.used_at.push(self_index);
             var_data_index
         } else {
             // If we're in a binding expression then it might the first time we
             // encounter the variable, so add a `VarData` entry.
             debug_assert_eq!(declaration.kind, VariableKind::Binding);
             let var_type = self.determine_inference_type_from_parser_type_elements(
                 &declaration.parser_type.elements, true
             );
             let var_data_index = self.var_data.len();
             self.var_data.push(VarData{
                 var_id: declaration.this,
                 var_type,
                 used_at: vec![self_index],
                 linked_var: None,
             });
             var_data_index
         };
         let node = &mut self.infer_nodes[self_index];
         node.inference_rule = InferenceRule::VariableExpr(InferenceRuleVariableExpr{
             var_data_index,
         });
         self.parent_index = old_parent;
         self.progress_inference_rule_variable_expr(ctx, self_index)?;
         return Ok(self_index);
+    }
+}
 // -----------------------------------------------------------------------------
 // PassTyping - Type-inference progression
 // -----------------------------------------------------------------------------
 impl PassTyping {
     #[allow(dead_code)] // used when debug flag at the top of this file is true.
     fn debug_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.infer_nodes[expr_idx as usize].expr_type;
     fn debug_get_display_name(&self, ctx: &Ctx, node_index: InferNodeIndex) -> String {
         let expr_type = &self.infer_nodes[node_index].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.node_queued.is_empty() {
             while !self.node_queued.is_empty() {
                 let node_index = self.node_queued.pop_front().unwrap();
                 self.progress_inference_rule(ctx, node_index)?;
+            }
             // Nothing is queued anymore. However we might have integer literals
             // whose type cannot be inferred. For convenience's sake we'll
             // infer these to be s32.
             for (infer_node_index, infer_node) in self.infer_nodes.iter_mut().enumerate() {
                 let expr_type = &mut infer_node.expr_type;
                 if !expr_type.is_done && expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {
                     // Force integer type to s32
                     expr_type.parts[0] = InferenceTypePart::SInt32;
                     expr_type.is_done = true;
                     // Requeue expression (and its parent, if it exists)
                     self.node_queued.push_back(infer_node_index);
                     if let Some(node_parent_index) = infer_node.parent_index {
                         self.node_queued.push_back(node_parent_index);
+                    }
+                }
+            }
+        }
         // Helper for transferring polymorphic variables to concrete types and
         // checking if they're completely specified
         fn inference_type_to_concrete_type(
             ctx: &Ctx, expr_id: ExpressionId, inference: &Vec<InferenceType>,
         fn poly_data_type_to_concrete_type(
             ctx: &Ctx, expr_id: ExpressionId, inference_poly_args: &Vec<InferenceType>,
             first_concrete_part: ConcreteTypePart,
         ) -> Result<ConcreteType, ParseError> {
             // Prepare storage vector
             let mut num_inference_parts = 0;
-            for inference_type in inference {
+            for inference_type in inference_poly_args {
                 num_inference_parts += inference_type.parts.len();
+            }
             let mut concrete_type = ConcreteType{
                 parts: Vec::with_capacity(1 + num_inference_parts),
             };
             concrete_type.parts.push(first_concrete_part);
             // Go through all polymorphic arguments and add them to the concrete
             // types.
-            for (poly_idx, poly_type) in inference.iter().enumerate() {
+            for (poly_idx, poly_type) in inference_poly_args.iter().enumerate() {
                 if !poly_type.is_done {
                     let expr = &ctx.heap[expr_id];
                     let definition = match expr {
                         Expression::Call(expr) => expr.procedure.upcast(),
                         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.operation_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)
+                        )
                     ));
+                }
                 poly_type.write_concrete_type(&mut concrete_type);
+            }
             Ok(concrete_type)
+        }
         // Inference is now done. But we may still have polymorphic data that is
         // not fully inferred, while the associated expression is. An example
         // being a polymorphic function call: we need to instantiate a
         // monomorph, so need all of its polymorphic variables, but the call
         // expression was only interested in the return value.
         for infer_expr in self.infer_nodes.iter_mut() {
             if !infer_expr.expr_type.is_done {
                 let expr = &ctx.heap[infer_expr.expr_id];
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, expr.full_span(), format!(
                         "could not fully infer the type of this expression (got '{}')",
                         infer_expr.expr_type.display_name(&ctx.heap)
+                    )
                 ));
+            }
             // Expression is fine, check if any extra data is attached
             if infer_expr.poly_data_index < 0 { continue; }
             let poly_data = &self.poly_data[infer_expr.poly_data_index as usize];
             // 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[infer_expr.expr_id] {
                 Expression::Call(expr) => {
                     // Check if it is not a builtin function. If not, then
                     // construct the first part of the concrete type.
                     let first_concrete_part = if expr.method == Method::UserProcedure {
                         ConcreteTypePart::Function(expr.procedure, poly_data.poly_vars.len() as u32)
                     } else if expr.method == Method::UserComponent {
                         ConcreteTypePart::Component(expr.procedure, poly_data.poly_vars.len() as u32)
                     } else {
                         // Builtin function
                         continue;
                     };
                     let definition_id = expr.procedure.upcast();
                     let concrete_type = inference_type_to_concrete_type(
                         ctx, infer_expr.expr_id, &poly_data.poly_vars, first_concrete_part
                     )?;
                     match ctx.types.get_procedure_monomorph_type_id(&definition_id, &concrete_type.parts) {
                         Some(type_id) => {
                             // Already typechecked, or already put into the resolve queue
                             infer_expr.type_id = type_id;
                         },
                         None => {
                             // Not typechecked yet, so add an entry in the queue
                             let reserved_type_id = ctx.types.reserve_procedure_monomorph_type_id(&definition_id, concrete_type);
                             infer_expr.type_id = reserved_type_id;
                             queue.push(ResolveQueueElement {
                                 root_id: ctx.heap[definition_id].defined_in(),
                                 definition_id,
                                 reserved_type_id,
                             });
+                        }
+                    }
                 },
                 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 first_concrete_part = ConcreteTypePart::Instance(definition_id, poly_data.poly_vars.len() as u32);
                     let concrete_type = inference_type_to_concrete_type(
                         ctx, infer_expr.expr_id, &poly_data.poly_vars, first_concrete_part
                     )?;
                     let type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, concrete_type)?;
                     infer_expr.type_id = type_id;
                 },
                 Expression::Select(_) => {
                     debug_assert!(infer_expr.field_or_monomorph_index >= 0);
                 },
                 _ => {
                     unreachable!("handling extra data for expression {:?}", &ctx.heap[infer_expr.expr_id]);
+                }
+            }
+        }
         // Every expression checked, and new monomorphs are queued. Transfer the
         // expression information to the AST. If this is the first time we're
         // visiting this procedure then we assign expression indices as well.
         let procedure = &mut ctx.heap[self.procedure_id];
         let procedure = &ctx.heap[self.procedure_id];
         let num_infer_nodes = self.infer_nodes().len();
         let mut monomorph = ProcedureDefinitionMonomorph{
             argument_types: Vec::with_capacity(procedure.parameters.len()),
-            expr_info: Vec::with_capacity(self.infer_nodes().len()), // TODO: Initial reservation
+            expr_info: Vec::with_capacity(num_infer_nodes),
         };
         // - Write the arguments
         // For all of the expressions look up the TypeId (or create a new one).
         // For function calls and component instantiations figure out if they
         // need to be typechecked
         for infer_node in self.infer_nodes.iter_mut() {
             // Determine type ID
             let expr = &ctx.heap[infer_node.expr_id];
             let poly_data = &self.poly_data[infer_node.poly_data_index as usize];
             // TODO: Maybe optimize? Split insertion up into lookup, then clone
             //  if needed?
             let mut concrete_type = ConcreteType::default();
             infer_node.expr_type.write_concrete_type(&mut concrete_type);
             let info_type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, concrete_type)?;
             // Determine procedure type ID, i.e. a called/instantiated
             // procedure's signature.
             let info_variant = if let Expression::Call(expr) = expr {
                 // Construct full function type. If not yet typechecked then
                 // queue it for typechecking.
                 debug_assert!(expr.method.is_user_defined() || expr.method.is_public_builtin());
                 let num_poly_vars = poly_data.poly_vars.len() as u32;
                 let first_part = match expr.method {
                     Method::UserFunction => ConcreteTypePart::Function(expr.procedure, num_poly_vars),
                     Method::UserComponent => ConcreteTypePart::Component(expr.procedure, num_poly_vars),
                     _ => ConcreteTypePart::Function(expr.procedure, num_poly_vars),
                 };
                 let definition_id = expr.procedure.upcast();
                 let signature_type = poly_data_type_to_concrete_type(
                     ctx, infer_node.expr_id, &poly_data.poly_vars, first_part
                 )?;
                 let (type_id, monomorph_index) = if let Some(type_id) = ctx.types.get_procedure_monomorph_type_id(&definition_id, &signature_type.parts) {
                     // Procedure is already typechecked
                     let monomorph_index = ctx.types.get_monomorph(type_id).variant.as_procedure().monomorph_index;
                     (type_id, monomorph_index)
                 } else {
                     // Procedure is not yet typechecked, reserve a TypeID and a monomorph index
                     let procedure_to_check = &mut ctx.heap[expr.procedure];
                     let monomorph_index = procedure_to_check.monomorphs.len() as u32;
                     procedure_to_check.monomorphs.push(ProcedureDefinitionMonomorph::new_invalid());
                     let type_id = ctx.types.reserve_procedure_monomorph_type_id(&definition_id, signature_type, monomorph_index);
                     queue.push(ResolveQueueElement{
                         root_id: ctx.heap[definition_id].defined_in(),
                         definition_id,
                         reserved_type_id: type_id,
                         reserved_monomorph_index: monomorph_index,
                     });
                     (type_id, monomorph_index)
                 };
                 ExpressionInfoVariant::Procedure(type_id, monomorph_index)
             } else if let Expression::Select(expr) = expr {
                 ExpressionInfoVariant::Select(infer_node.field_index)
             } else {
                 ExpressionInfoVariant::Generic
             };
             infer_node.info_type_id = info_type_id;
             infer_node.info_variant = info_variant;
+        }
         // Write the types of the arguments
         for parameter_id in procedure.parameters.iter().copied() {
             let mut concrete = ConcreteType::default();
             let var_data = self.var_data.iter().find(|v| v.var_id == parameter_id).unwrap();
             var_data.var_type.write_concrete_type(&mut concrete);
             let type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, concrete)?;
             monomorph.argument_types.push(type_id)
+        }
         for infer_node in self.infer_nodes.iter() {
             let expr = &ctx.heap[infer_node.expr_id];
         // Determine if we have already assigned type indices to the expressions
         // before (the indices that, for a monomorph, can retrieve the type of
         // the expression).
         let has_type_indices = self.reserved_monomorph_index == 0;
         if has_type_indices {
             // already have indices, so resize and then index into it
             monomorph.expr_info.resize_with(num_infer_nodes, ExpressionInfo::new_invalid());
             for infer_node in self.infer_nodes.iter() {
                 let type_index = ctx.heap[infer_node.expr_id].type_index();
                 monomorph.expr_info[type_index as usize] = infer_node.as_expression_info();
+            }
         } else {
             // no indices yet, need to be assigned in AST
             for infer_node in self.infer_nodes.iter() {
                 let type_index = monomorph.expr_info.len();
                 monomorph.expr_info.push(infer_node.as_expression_info());
                 *ctx.heap[infer_node.expr_id].type_index_mut() = type_index as i32;
+            }
+        }
         // - Write the expression data
         target.expr_data.reserve(self.infer_nodes.len());
         for infer_expr in self.infer_nodes.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_index,
                 type_id: infer_expr.type_id,
             });
+        }
         // Push the information into the AST
         let procedure = &mut ctx.heap[self.procedure_id];
         procedure.monomorphs[self.reserved_monomorph_index as usize] = monomorph;
         Ok(())
+    }
     fn progress_inference_rule(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         use InferenceRule as IR;
         let node = &self.infer_nodes[node_index];
         match &node.inference_rule {
             IR::Noop =>
                 unreachable!(),
             IR::MonoTemplate(_) =>
                 self.progress_inference_rule_mono_template(ctx, node_index),
             IR::BiEqual(_) =>
                 self.progress_inference_rule_bi_equal(ctx, node_index),
             IR::TriEqualArgs(_) =>
                 self.progress_inference_rule_tri_equal_args(ctx, node_index),
             IR::TriEqualAll(_) =>
                 self.progress_inference_rule_tri_equal_all(ctx, node_index),
             IR::Concatenate(_) =>
                 self.progress_inference_rule_concatenate(ctx, node_index),
             IR::IndexingExpr(_) =>
                 self.progress_inference_rule_indexing_expr(ctx, node_index),
             IR::SlicingExpr(_) =>
                 self.progress_inference_rule_slicing_expr(ctx, node_index),
             IR::SelectStructField(_) =>
                 self.progress_inference_rule_select_struct_field(ctx, node_index),
             IR::SelectTupleMember(_) =>
                 self.progress_inference_rule_select_tuple_member(ctx, node_index),
             IR::LiteralStruct(_) =>
                 self.progress_inference_rule_literal_struct(ctx, node_index),
             IR::LiteralEnum =>
                 self.progress_inference_rule_literal_enum(ctx, node_index),
             IR::LiteralUnion(_) =>
                 self.progress_inference_rule_literal_union(ctx, node_index),
             IR::LiteralArray(_) =>
                 self.progress_inference_rule_literal_array(ctx, node_index),
             IR::LiteralTuple(_) =>
                 self.progress_inference_rule_literal_tuple(ctx, node_index),
             IR::CastExpr(_) =>
                 self.progress_inference_rule_cast_expr(ctx, node_index),
             IR::CallExpr(_) =>
                 self.progress_inference_rule_call_expr(ctx, node_index),
             IR::VariableExpr(_) =>
                 self.progress_inference_rule_variable_expr(ctx, node_index),
+        }
+    }
     fn progress_inference_rule_mono_template(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = *node.inference_rule.as_mono_template();
         let progress = self.progress_template(ctx, node_index, rule.application, rule.template)?;
         if progress { self.queue_node_parent(node_index); }
         return Ok(());
+    }
     fn progress_inference_rule_bi_equal(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_bi_equal();
         let template = rule.template;
         let arg_index = rule.argument_index;
         let base_progress = self.progress_template(ctx, node_index, template.application, template.template)?;
         let (node_progress, arg_progress) = self.apply_equal2_constraint(ctx, node_index, node_index, 0, arg_index, 0)?;
         if base_progress || node_progress { self.queue_node_parent(node_index); }
         if arg_progress { self.queue_node(arg_index); }
         return Ok(())
+    }
     fn progress_inference_rule_tri_equal_args(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_tri_equal_args();
         let result_template = rule.result_template;
         let argument_template = rule.argument_template;
         let arg1_index = rule.argument1_index;
         let arg2_index = rule.argument2_index;
         let self_template_progress = self.progress_template(ctx, node_index, result_template.application, result_template.template)?;
         let arg1_template_progress = self.progress_template(ctx, arg1_index, argument_template.application, argument_template.template)?;
         let (arg1_progress, arg2_progress) = self.apply_equal2_constraint(ctx, node_index, arg1_index, 0, arg2_index, 0)?;
         if self_template_progress { self.queue_node_parent(node_index); }
         if arg1_template_progress || arg1_progress { self.queue_node(arg1_index); }
         if arg2_progress { self.queue_node(arg2_index); }
         return Ok(());
+    }
     fn progress_inference_rule_tri_equal_all(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_tri_equal_all();
@@ @@ -2268,330 +2281,330 @@ impl PassTyping { @@
         // Subject is arraylike, index in integerlike
         let subject_template_progress = self.apply_template_constraint(ctx, subject_index, &ARRAYLIKE_TEMPLATE)?;
         let index_template_progress = self.apply_template_constraint(ctx, index_index, &INTEGERLIKE_TEMPLATE)?;
         // If subject is type `Array<T>`, then expr type is `T`
         let (node_progress, subject_progress) =
             self.apply_equal2_constraint(ctx, node_index, node_index, 0, subject_index, 1)?;
         if node_progress { self.queue_node_parent(node_index); }
         if subject_template_progress || subject_progress { self.queue_node(subject_index); }
         if index_template_progress { self.queue_node(index_index); }
         return Ok(());
+    }
     fn progress_inference_rule_slicing_expr(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_slicing_expr();
         let subject_index = rule.subject_index;
         let from_index_index = rule.from_index;
         let to_index_index = rule.to_index;
         debug_log!("Rule slicing [node: {}, expr: {}]", node_index, node.expr_id.index);
         // Subject is arraylike, indices are integerlike
         let subject_template_progress = self.apply_template_constraint(ctx, subject_index, &ARRAYLIKE_TEMPLATE)?;
         let from_template_progress = self.apply_template_constraint(ctx, from_index_index, &INTEGERLIKE_TEMPLATE)?;
         let to_template_progress = self.apply_template_constraint(ctx, to_index_index, &INTEGERLIKE_TEMPLATE)?;
         let (from_index_progress, to_index_progress) =
             self.apply_equal2_constraint(ctx, node_index, from_index_index, 0, to_index_index, 0)?;
         // Same as array indexing: result depends on whether subject is string
         // or array
         let (is_string, is_not_string) = self.type_is_certainly_or_certainly_not_string(node_index);
         println!("DEBUG: Running slicing, is_str = {}, is_not_str = {}", is_string, is_not_string);
         let (node_progress, subject_progress) = if is_string {
             // Certainly a string
+            (
                 self.apply_forced_constraint(ctx, node_index, &STRING_TEMPLATE)?,
                 false
+            )
         } else if is_not_string {
             // Certainly not a string, apply template constraint. Then make sure
             // that if we have an `Array<T>`, that the slice produces `Slice<T>`
             let node_template_progress = self.apply_template_constraint(ctx, node_index, &SLICE_TEMPLATE)?;
             let (node_progress, subject_progress) =
                 self.apply_equal2_constraint(ctx, node_index, node_index, 1, subject_index, 1)?;
+            (
                 node_template_progress || node_progress,
                 subject_progress
+            )
         } else {
             // Not sure yet
             let node_template_progress = self.apply_template_constraint(ctx, node_index, &ARRAYLIKE_TEMPLATE)?;
             let (node_progress, subject_progress) =
                 self.apply_equal2_constraint(ctx, node_index, node_index, 1, subject_index, 1)?;
+            (
                 node_template_progress || node_progress,
                 subject_progress
+            )
         };
         if node_progress { self.queue_node_parent(node_index); }
         if subject_template_progress || subject_progress { self.queue_node(subject_index); }
         if from_template_progress || from_index_progress { self.queue_node(from_index_index); }
         if to_template_progress || to_index_progress { self.queue_node(to_index_index); }
         return Ok(());
+    }
     fn progress_inference_rule_select_struct_field(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_select_struct_field();
         let subject_index = rule.subject_index;
         let selected_field = rule.selected_field.clone();
         fn get_definition_id_from_inference_type(inference_type: &InferenceType) -> Result<Option<DefinitionId>, ()> {
             for part in inference_type.parts.iter() {
                 if part.is_marker() { continue; }
                 if !part.is_concrete() { break; }
                 if let InferenceTypePart::Instance(definition_id, _) = part {
                     return Ok(Some(*definition_id));
                 } else {
                     return Err(())
+                }
+            }
             // Nothing is known yet
             return Ok(None);
+        }
-        if node.field_or_monomorph_index < 0 {
+        if node.field_index < 0 {
             // Don't know the subject definition, hence the field yet. Try to
             // determine it.
             let subject_node = &self.infer_nodes[subject_index];
             match get_definition_id_from_inference_type(&subject_node.expr_type) {
                 Ok(Some(definition_id)) => {
                     // Determined definition of subject for the first time.
                     let base_definition = ctx.types.get_base_definition(&definition_id).unwrap();
                     let struct_definition = if let DefinedTypeVariant::Struct(struct_definition) = &base_definition.definition {
                         struct_definition
                     } else {
                         return Err(ParseError::new_error_at_span(
                             &ctx.module().source, selected_field.span, format!(
                                 "Can only apply field access to structs, got a subject of type '{}'",
                                 subject_node.expr_type.display_name(&ctx.heap)
+                            )
                         ));
                     };
                     // Seek the field that is referenced by the select
                     // expression
                     let mut field_found = false;
                     for (field_index, field) in struct_definition.fields.iter().enumerate() {
                         if field.identifier.value == selected_field.value {
                             // Found the field of interest
                             field_found = true;
                             let node = &mut self.infer_nodes[node_index];
-                            node.field_or_monomorph_index = field_index as i32;
+                            node.field_index = field_index as i32;
                             break;
+                        }
+                    }
                     if !field_found {
                         let struct_definition = ctx.heap[definition_id].as_struct();
                         return Err(ParseError::new_error_at_span(
                             &ctx.module().source, selected_field.span, format!(
                                 "this field does not exist on the struct '{}'",
                                 struct_definition.identifier.value.as_str()
+                            )
                         ));
+                    }
                     // Insert the initial data needed to infer polymorphic
                     // fields
                     let extra_index = self.insert_initial_select_polymorph_data(ctx, node_index, definition_id);
                     let node = &mut self.infer_nodes[node_index];
                     node.poly_data_index = extra_index;
                 },
                 Ok(None) => {
                     // We don't know what to do yet, because we don't know the
                     // subject type yet.
                     return Ok(())
                 },
                 Err(()) => {
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, rule.selected_field.span, format!(
                             "Can only apply field access to structs, got a subject of type '{}'",
                             subject_node.expr_type.display_name(&ctx.heap)
+                        )
                     ));
                 },
+            }
+        }
         // If here then the field index is known, hence we can start inferring
         // the type of the selected field
         let field_expr_id = self.infer_nodes[node_index].expr_id;
         let subject_expr_id = self.infer_nodes[subject_index].expr_id;
         let mut poly_progress_section = self.poly_progress_buffer.start_section();
         let (_, progress_subject_1) = self.apply_polydata_equal2_constraint(
             ctx, node_index, subject_expr_id, "selected struct's",
             PolyDataTypeIndex::Associated(0), 0, subject_index, 0, &mut poly_progress_section
         )?;
         let (_, progress_field_1) = self.apply_polydata_equal2_constraint(
             ctx, node_index, field_expr_id, "selected field's",
             PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section
         )?;
         // Maybe make progress on types due to inferred polymorphic variables
         let progress_subject_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Associated(0), subject_index, &poly_progress_section
         );
         let progress_field_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Returned, node_index, &poly_progress_section
         );
         if progress_subject_1 || progress_subject_2 { self.queue_node(subject_index); }
         if progress_field_1 || progress_field_2 { self.queue_node_parent(node_index); }
         poly_progress_section.forget();
         self.finish_polydata_constraint(node_index);
         return Ok(())
+    }
     fn progress_inference_rule_select_tuple_member(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_select_tuple_member();
         let subject_index = rule.subject_index;
         let tuple_member_index = rule.selected_index;
-        if node.field_or_monomorph_index < 0 {
+        if node.field_index < 0 {
             let subject_type = &self.infer_nodes[subject_index].expr_type;
             let tuple_size = get_tuple_size_from_inference_type(subject_type);
             let tuple_size = match tuple_size {
                 Ok(Some(tuple_size)) => {
                     tuple_size
                 },
                 Ok(None) => {
                     // We can't infer anything yet
                     return Ok(())
                 },
                 Err(()) => {
                     let select_expr_span = ctx.heap[node.expr_id].full_span();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, select_expr_span, format!(
                             "tuple element select cannot be applied to a subject of type '{}'",
                             subject_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
             };
             // If here then we at least have the tuple size. Now check if the
             // index doesn't exceed that size.
             if tuple_member_index >= tuple_size as u64 {
                 let select_expr_span = ctx.heap[node.expr_id].full_span();
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, select_expr_span, format!(
                         "element index {} is out of bounds, tuple has {} elements",
                         tuple_member_index, tuple_size
+                    )
                 ));
+            }
             // Within bounds, set index on the type inference node
             let node = &mut self.infer_nodes[node_index];
-            node.field_or_monomorph_index = tuple_member_index as i32;
+            node.field_index = tuple_member_index as i32;
+        }
         // If here then we know we can use `tuple_member_index`. We need to keep
         // computing the offset to the subtype, as its value changes during
         // inference
         let subject_type = &self.infer_nodes[subject_index].expr_type;
         let mut selected_member_start_index = 1; // start just after the InferenceTypeElement::Tuple
         for _ in 0..tuple_member_index {
             selected_member_start_index = InferenceType::find_subtree_end_idx(&subject_type.parts, selected_member_start_index);
+        }
         let (progress_member, progress_subject) = self.apply_equal2_constraint(
             ctx, node_index, node_index, 0, subject_index, selected_member_start_index
         )?;
         if progress_member { self.queue_node_parent(node_index); }
         if progress_subject { self.queue_node(subject_index); }
         return Ok(());
+    }
     fn progress_inference_rule_literal_struct(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let node_expr_id = node.expr_id;
         let rule = node.inference_rule.as_literal_struct();
         // For each of the fields in the literal struct, apply the type equality
         // constraint. If the literal is polymorphic, then we try to progress
         // their types during this process
         let element_indices_section = self.index_buffer.start_section_initialized(&rule.element_indices);
         let mut poly_progress_section = self.poly_progress_buffer.start_section();
         for (field_index, field_node_index) in element_indices_section.iter_copied().enumerate() {
             let field_expr_id = self.infer_nodes[field_node_index].expr_id;
             let (_, progress_field) = self.apply_polydata_equal2_constraint(
                 ctx, node_index, field_expr_id, "struct field's",
                 PolyDataTypeIndex::Associated(field_index), 0,
                 field_node_index, 0, &mut poly_progress_section
             )?;
             if progress_field { self.queue_node(field_node_index); }
+        }
         // Now we do the same thing for the struct literal expression (the type
         // of the struct itself).
         let (_, progress_literal_1) = self.apply_polydata_equal2_constraint(
             ctx, node_index, node_expr_id, "struct literal's",
             PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section
         )?;
         // And the other way around: if any of our polymorphic variables are
         // more specific then they were before, then we forward that information
         // back to our struct/fields.
         for (field_index, field_node_index) in element_indices_section.iter_copied().enumerate() {
             let progress_field = self.apply_polydata_polyvar_constraint(
                 ctx, node_index, PolyDataTypeIndex::Associated(field_index),
                 field_node_index, &poly_progress_section
             );
             if progress_field { self.queue_node(field_node_index); }
+        }
         let progress_literal_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Returned,
             node_index, &poly_progress_section
         );
         if progress_literal_1 || progress_literal_2 { self.queue_node_parent(node_index); }
         poly_progress_section.forget();
         element_indices_section.forget();
         self.finish_polydata_constraint(node_index);
         return Ok(())
+    }
     fn progress_inference_rule_literal_enum(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let node_expr_id = node.expr_id;
         let mut poly_progress_section = self.poly_progress_buffer.start_section();
         // An enum literal type is simply, well, the enum's type. However, it
         // might still have polymorphic variables, hence the use of `PolyData`.
         let (_, progress_literal_1) = self.apply_polydata_equal2_constraint(
             ctx, node_index, node_expr_id, "enum literal's",
             PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section
         )?;
         let progress_literal_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Returned, node_index, &poly_progress_section
         );
         if progress_literal_1 || progress_literal_2 { self.queue_node_parent(node_index); }
         poly_progress_section.forget();
         self.finish_polydata_constraint(node_index);
         return Ok(());
@@ @@ -3309,195 +3322,196 @@ impl PassTyping { @@
         let mut last_index_requiring_inference = 0;
         for prev_argument_index in 0..arguments.len() - 1 {
             let next_argument_index = prev_argument_index + 1;
             let prev_node_index = arguments[prev_argument_index];
             let next_node_index = arguments[next_argument_index];
             let (prev_progress, next_progress) = self.apply_equal2_constraint(
                 ctx, outer_node_index, prev_node_index, 0, next_node_index, 0
             )?;
             if prev_progress {
                 // Previous node is progress, so every type in front of it needs
                 // to be reinferred.
                 progress[prev_argument_index] = true;
                 last_index_requiring_inference = prev_argument_index;
+            }
             progress[next_argument_index] = next_progress;
+        }
         // Apply inference using the most progressed type (the last one) to the
         // ones that did not obtain this information during the inference
         // process.
         let last_argument_node_index = arguments[arguments.len() - 1];
         let last_argument_type: *mut _ = &mut self.infer_nodes[last_argument_node_index].expr_type;
         for argument_index in 0..last_index_requiring_inference {
             // We can cheat, we know the LHS is less specific than the right
             // hand side, so:
             let argument_node_index = arguments[argument_index];
             let argument_type = &mut self.infer_nodes[argument_node_index].expr_type;
             unsafe {
                 // safety: we're dealing with different vectors, so cannot alias
                 argument_type.replace_subtree(0, &(*last_argument_type).parts);
+            }
             progress[argument_index] = true;
+        }
         return Ok(());
+    }
     /// Determines the `InferenceType` for the expression based on the
     /// expression parent (this is not done if the parent is a regular 'ol
     /// expression). Expects `parent_index` to be set to the parent of the
     /// inference node that is created here.
     fn insert_initial_inference_node(
         &mut self, ctx: &mut Ctx, expr_id: ExpressionId
     ) -> Result<InferNodeIndex, ParseError> {
         use ExpressionParent as EP;
         use InferenceTypePart as ITP;
         // Set the initial inference type based on the expression parent.
         let expr = &ctx.heap[expr_id];
         let inference_type = match expr.parent() {
             EP::None =>
                 // Should have been set by linker
                 unreachable!(),
             EP::Memory(_) | EP::ExpressionStmt(_) =>
                 // Determined during type inference
                 InferenceType::new(false, false, vec![ITP::Unknown]),
             EP::Expression(parent_id, idx_in_parent) => {
                 // If we are the test expression of a conditional expression,
                 // then we must resolve to a boolean
                 let is_conditional = if let Expression::Conditional(_) = &ctx.heap[*parent_id] {
                     true
                 } else {
                     false
                 };
                 if is_conditional && *idx_in_parent == 0 {
                     InferenceType::new(false, true, vec![ITP::Bool])
                 } else {
                     InferenceType::new(false, false, vec![ITP::Unknown])
+                }
             },
             EP::If(_) | EP::While(_) =>
                 // Must be a boolean
                 InferenceType::new(false, true, vec![ITP::Bool]),
             EP::Return(_) => {
                 // Must match the return type of the function
                 debug_assert_eq!(self.procedure_kind, ProcedureKind::Function);
                 let returned = &ctx.heap[self.procedure_id].return_type.as_ref().unwrap();
                 self.determine_inference_type_from_parser_type_elements(&returned.elements, true)
             },
             EP::New(_) =>
                 // Must be a component call, which we assign a "Void" return
                 // type
                 InferenceType::new(false, true, vec![ITP::Void]),
         };
         let infer_index = self.infer_nodes.len() as InferNodeIndex;
         self.infer_nodes.push(InferenceNode {
             expr_type: inference_type,
             expr_id,
             inference_rule: InferenceRule::Noop,
             parent_index: self.parent_index,
-            field_or_monomorph_index: -1,
+            field_index: -1,
             poly_data_index: -1,
             type_id: TypeId::new_invalid(),
             info_type_id: TypeId::new_invalid(),
             info_variant: ExpressionInfoVariant::Generic,
         });
         return Ok(infer_index);
+    }
     fn insert_initial_call_polymorph_data(
         &mut self, ctx: &mut Ctx, call_id: CallExpressionId
     ) -> PolyDataIndex {
         // Note: the polymorph variables may be partially specified and may
         // contain references to the wrapping definition's (i.e. the proctype
         // we are currently visiting) polymorphic arguments.
         //
         // The arguments of the call may refer to polymorphic variables in the
         // definition of the function we're calling, not of the wrapping
         // definition. We insert markers in these inferred types to be able to
         // map them back and forth to the polymorphic arguments of the function
         // we are calling.
         let call = &ctx.heap[call_id];
         // Handle the polymorphic arguments (if there are any)
         let num_poly_args = call.parser_type.elements[0].variant.num_embedded();
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in call.parser_type.iter_embedded(0) {
             poly_args.push(self.determine_inference_type_from_parser_type_elements(embedded_elements, true));
+        }
         // Handle the arguments and return types
         let definition = &ctx.heap[call.procedure];
         debug_assert_eq!(poly_args.len(), definition.poly_vars.len());
         let mut parameter_types = Vec::with_capacity(definition.parameters.len());
         let parameter_section = self.var_buffer.start_section_initialized(&definition.parameters);
         for parameter_id in parameter_section.iter_copied() {
             let param = &ctx.heap[parameter_id];
             parameter_types.push(self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, false));
+        }
         parameter_section.forget();
         let return_type = match &definition.return_type {
             None => {
                 // Component, so returns a "Void"
                 debug_assert_ne!(definition.kind, ProcedureKind::Function);
                 InferenceType::new(false, true, vec![InferenceTypePart::Void])
             },
             Some(returned) => {
                 debug_assert_eq!(definition.kind, ProcedureKind::Function);
                 self.determine_inference_type_from_parser_type_elements(&returned.elements, false)
+            }
         };
         let extra_data_idx = self.poly_data.len() as PolyDataIndex;
         self.poly_data.push(PolyData {
             first_rule_application: true,
             definition_id: call.procedure.upcast(),
             poly_vars: poly_args,
             expr_types: PolyDataTypes {
                 associated: parameter_types,
                 returned: return_type
+            }
         });
         return extra_data_idx
+    }
     fn insert_initial_struct_polymorph_data(
         &mut self, ctx: &mut Ctx, lit_id: LiteralExpressionId,
     ) -> PolyDataIndex {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_struct();
         // Handle polymorphic arguments
         let num_embedded = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         let mut poly_args = Vec::with_capacity(num_embedded);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle parser types on struct definition
         let defined_type = ctx.types.get_base_definition(&literal.definition).unwrap();
         let struct_type = defined_type.definition.as_struct();
         debug_assert_eq!(poly_args.len(), defined_type.poly_vars.len());
         // Note: programmer is capable of specifying fields in a struct literal
         // in a different order than on the definition. We take the literal-
         // specified order to be leading.
         let mut embedded_types = Vec::with_capacity(struct_type.fields.len());
         for lit_field in literal.fields.iter() {
             let def_field = &struct_type.fields[lit_field.field_idx];
             let inference_type = self.determine_inference_type_from_parser_type_elements(&def_field.parser_type.elements, false);
             embedded_types.push(inference_type);
+        }
         // Return type is the struct type itself, with the appropriate
@@ @@ -3561,193 +3575,193 @@ impl PassTyping { @@
         for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {
             if !poly_var.is_done { enum_type_done = false; }
             parts.push(ITP::Marker(poly_var_idx as u32));
             parts.extend(poly_var.parts.iter().cloned());
+        }
         debug_assert_eq!(parts.len(), parts_reserved);
         let enum_type = InferenceType::new(!poly_args.is_empty(), enum_type_done, parts);
         let extra_data_index = self.poly_data.len() as PolyDataIndex;
         self.poly_data.push(PolyData {
             first_rule_application: true,
             definition_id: literal.definition,
             poly_vars: poly_args,
             expr_types: PolyDataTypes {
                 associated: Vec::new(),
                 returned: enum_type,
             },
         });
         return extra_data_index;
+    }
     /// Inserts the extra polymorphic data struct for unions. The polymorphic
     /// arguments may be partially determined from embedded values in the union.
     fn insert_initial_union_polymorph_data(
         &mut self, ctx: &Ctx, lit_id: LiteralExpressionId
     ) -> PolyDataIndex {
         use InferenceTypePart as ITP;
         let literal = ctx.heap[lit_id].value.as_union();
         // Construct the polymorphic variables
         let num_poly_args = literal.parser_type.elements[0].variant.num_embedded();
         let mut total_num_poly_parts = 0;
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in literal.parser_type.iter_embedded(0) {
             let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);
             total_num_poly_parts += poly_type.parts.len();
             poly_args.push(poly_type);
+        }
         // Handle any of the embedded values in the variant, if specified
         let definition_id = literal.definition;
         let type_definition = ctx.types.get_base_definition(&definition_id).unwrap();
         let union_definition = type_definition.definition.as_union();
         debug_assert_eq!(poly_args.len(), type_definition.poly_vars.len());
         let variant_definition = &union_definition.variants[literal.variant_idx];
         debug_assert_eq!(variant_definition.embedded.len(), literal.values.len());
         let mut embedded = Vec::with_capacity(variant_definition.embedded.len());
         for embedded_parser_type in &variant_definition.embedded {
             let inference_type = self.determine_inference_type_from_parser_type_elements(&embedded_parser_type.elements, false);
             embedded.push(inference_type);
+        }
         // Handle the type of the union itself
         let parts_reserved = 1 + poly_args.len() + total_num_poly_parts;
         let mut parts = Vec::with_capacity(parts_reserved);
         parts.push(ITP::Instance(definition_id, poly_args.len() as u32));
         let mut union_type_done = true;
         for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {
             if !poly_var.is_done { union_type_done = false; }
             parts.push(ITP::Marker(poly_var_idx as u32));
             parts.extend(poly_var.parts.iter().cloned());
+        }
         debug_assert_eq!(parts_reserved, parts.len());
         let union_type = InferenceType::new(!poly_args.is_empty(), union_type_done, parts);
         let extra_data_index = self.poly_data.len() as isize;
         self.poly_data.push(PolyData {
             first_rule_application: true,
             definition_id: literal.definition,
             poly_vars: poly_args,
             expr_types: PolyDataTypes {
                 associated: embedded,
                 returned: union_type,
             },
         });
         return extra_data_index;
+    }
     /// Inserts the extra polymorphic data struct. Assumes that the select
     /// expression's referenced (definition_id, field_idx) has been resolved.
     fn insert_initial_select_polymorph_data(
         &mut self, ctx: &Ctx, node_index: InferNodeIndex, struct_def_id: DefinitionId
     ) -> PolyDataIndex {
         use InferenceTypePart as ITP;
         let definition = ctx.heap[struct_def_id].as_struct();
         let node = &self.infer_nodes[node_index];
-        let field_index = node.field_or_monomorph_index as usize;
+        let field_index = node.field_index as usize;
         // Generate initial polyvar types and struct type
         // TODO: @Performance: we can immediately set the polyvars of the subject's struct type
         let num_poly_vars = definition.poly_vars.len();
         let mut poly_vars = Vec::with_capacity(num_poly_vars);
         let struct_parts_reserved = 1 + 2 * num_poly_vars;
         let mut struct_parts = Vec::with_capacity(struct_parts_reserved);
         struct_parts.push(ITP::Instance(struct_def_id, num_poly_vars as u32));
         for poly_idx in 0..num_poly_vars {
             poly_vars.push(InferenceType::new(true, false, vec![
                 ITP::Marker(poly_idx as u32), ITP::Unknown,
             ]));
             struct_parts.push(ITP::Marker(poly_idx as u32));
             struct_parts.push(ITP::Unknown);
+        }
         debug_assert_eq!(struct_parts.len(), struct_parts_reserved);
         // Generate initial field type
         let field_type = self.determine_inference_type_from_parser_type_elements(&definition.fields[field_index].parser_type.elements, false);
         let extra_data_index = self.poly_data.len() as PolyDataIndex;
         self.poly_data.push(PolyData {
             first_rule_application: true,
             definition_id: struct_def_id,
             poly_vars,
             expr_types: PolyDataTypes {
                 associated: vec![InferenceType::new(num_poly_vars != 0, num_poly_vars == 0, struct_parts)],
                 returned: field_type,
             },
         });
         return extra_data_index;
+    }
     /// Determines the initial InferenceType from the provided ParserType. This
     /// may be called with two kinds of intentions:
     /// 1. To resolve a ParserType within the body of a function, or on
     ///     polymorphic arguments to calls/instantiations within that body. This
     ///     means that the polymorphic variables are known and can be replaced
     ///     with the monomorph we're instantiating.
     /// 2. To resolve a ParserType on a called function's definition or on
     ///     an instantiated datatype's members. This means that the polymorphic
     ///     arguments inside those ParserTypes refer to the polymorphic
     ///     variables in the called/instantiated type's definition.
     /// In the second case we place InferenceTypePart::Marker instances such
     /// that we can perform type inference on the polymorphic variables.
     fn determine_inference_type_from_parser_type_elements(
         &mut self, elements: &[ParserTypeElement],
         use_definitions_known_poly_args: bool
     ) -> InferenceType {
         use ParserTypeVariant as PTV;
         use InferenceTypePart as ITP;
         let mut infer_type = Vec::with_capacity(elements.len());
         let mut has_inferred = false;
         let mut has_markers = false;
         for element in elements {
             match &element.variant {
                 // Compiler-only types
                 PTV::Void => { infer_type.push(ITP::Void); },
                 PTV::InputOrOutput => { infer_type.push(ITP::PortLike); has_inferred = true },
                 PTV::ArrayLike => { infer_type.push(ITP::ArrayLike); has_inferred = true },
                 PTV::IntegerLike => { infer_type.push(ITP::IntegerLike); has_inferred = true },
                 // Builtins
                 PTV::Message => {
                     // TODO: @types Remove the Message -> Byte hack at some point...
                     infer_type.push(ITP::Message);
                     infer_type.push(ITP::UInt8);
                 },
                 PTV::Bool => { infer_type.push(ITP::Bool); },
                 PTV::UInt8 => { infer_type.push(ITP::UInt8); },
                 PTV::UInt16 => { infer_type.push(ITP::UInt16); },
                 PTV::UInt32 => { infer_type.push(ITP::UInt32); },
                 PTV::UInt64 => { infer_type.push(ITP::UInt64); },
                 PTV::SInt8 => { infer_type.push(ITP::SInt8); },
                 PTV::SInt16 => { infer_type.push(ITP::SInt16); },
                 PTV::SInt32 => { infer_type.push(ITP::SInt32); },
                 PTV::SInt64 => { infer_type.push(ITP::SInt64); },
                 PTV::Character => { infer_type.push(ITP::Character); },
                 PTV::String => {
                     infer_type.push(ITP::String);
                     infer_type.push(ITP::Character);
                 },
                 // Special markers
                 PTV::IntegerLiteral => { unreachable!("integer literal type on variable type"); },
                 PTV::Inferred => {
                     infer_type.push(ITP::Unknown);
                     has_inferred = true;
                 },
                 // With nested types
                 PTV::Array => { infer_type.push(ITP::Array); },
                 PTV::Input => { infer_type.push(ITP::Input); },
                 PTV::Output => { infer_type.push(ITP::Output); },
                 PTV::Tuple(num_embedded) => { infer_type.push(ITP::Tuple(*num_embedded)); },

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

 /*
  * pass_validation_linking.rs
+ *
  * The pass that will validate properties of the AST statements (one is not
  * allowed to nest synchronous statements, instantiating components occurs in
  * the right places, etc.) and expressions (assignments may not occur in
  * arbitrary expressions).
+ *
  * Furthermore, this pass will also perform "linking", in the sense of: some AST
  * nodes have something to do with one another, so we link them up in this pass
  * (e.g. setting the parents of expressions, linking the control flow statements
  * like `continue` and `break` up to the respective loop statement, etc.).
+ *
  * There are several "confusing" parts about this pass:
+ *
  * Setting expression parents: this is the simplest one. The pass struct acts
  * like a little state machine. When visiting an expression it will set the
  * "parent expression" field of the pass to itself, then visit its child. The
  * child will look at this "parent expression" field to determine its parent.
+ *
  * Setting the `next` statement: the AST is a tree, but during execution we walk
  * a linear path through all statements. So where appropriate a statement may
  * set the "previous statement" field of the pass to itself. When visiting the
  * subsequent statement it will check this "previous statement", and if set, it
  * will link this previous statement up to itself. Not every statement has a
  * previous statement. Hence there are two patterns that occur: assigning the
  * `next` value, then clearing the "previous statement" field. And assigning the
  * `next` value, and then putting the current statement's ID in the "previous
  * statement" field. Because it is so common, this file contain two macros that
  * perform that operation.
+ *
  * To make storing types for polymorphic procedures simpler and more efficient,
  * we assign to each expression in the procedure a unique ID. This is what the
  * "next expression index" field achieves. Each expression simply takes the
  * current value, and then increments this counter.
  */
 use crate::collections::{ScopedBuffer};
 use crate::protocol::ast::*;
 use crate::protocol::input_source::*;
 use crate::protocol::parser::symbol_table::*;
 use crate::protocol::parser::type_table::*;
 use super::visitor::{
     BUFFER_INIT_CAP_SMALL,
     BUFFER_INIT_CAP_LARGE,
     Ctx,
     Visitor,
     VisitorResult
 };
 use crate::protocol::parser::ModuleCompilationPhase;
 struct ControlFlowStatement {
     in_sync: SynchronousStatementId,
     in_while: WhileStatementId,
     in_scope: ScopeId,
     statement: StatementId, // of 'break', 'continue' or 'goto'
+}
 /// This particular visitor will go through the entire AST in a recursive manner
 /// and check if all statements and expressions are legal (e.g. no "return"
 /// statements in component definitions), and will link certain AST nodes to
 /// their appropriate targets (e.g. goto statements, or function calls).
 ///
 /// This visitor will not perform control-flow analysis (e.g. making sure that
 /// each function actually returns) and will also not perform type checking. So
 /// the linking of function calls and component instantiations will be checked
 /// and linked to the appropriate definitions, but the return types and/or
 /// arguments will not be checked for validity.
 ///
 /// The main idea is, because we're visiting nodes in a tree, to do as much as
 /// we can while we have the memory in cache.
 pub(crate) struct PassValidationLinking {
     // Traversal state, all valid IDs if inside a certain AST element. Otherwise
     // `id.is_invalid()` returns true.
     in_sync: SynchronousStatementId,
     in_while: WhileStatementId, // to resolve labeled continue/break
     in_select_guard: SelectStatementId, // for detection/rejection of builtin calls
     in_select_arm: u32,
     in_test_expr: StatementId, // wrapping if/while stmt id
     in_binding_expr: BindingExpressionId, // to resolve variable expressions
     in_binding_expr_lhs: bool,
     // Traversal state, current scope (which can be used to find the parent
     // scope) and the definition variant we are considering.
     cur_scope: ScopeId,
     proc_id: ProcedureDefinitionId,
     proc_kind: ProcedureKind,
     // "Trailing" traversal state, set be child/prev stmt/expr used by next one
     prev_stmt: StatementId,
     expr_parent: ExpressionParent,
     // Set by parent to indicate that child expression must be assignable. The
     // child will throw an error if it is not assignable. The stored span is
     // used for the error's position
     must_be_assignable: Option<InputSpan>,
     // Keeping track of relative positions and unique IDs.
     relative_pos_in_parent: i32, // of statements: to determine when variables are visible
     next_expr_index: i32, // to arrive at a unique ID for all expressions within a definition
     // Control flow statements that require label resolving
     control_flow_stmts: Vec<ControlFlowStatement>,
     // Various temporary buffers for traversal. Essentially working around
     // Rust's borrowing rules since it cannot understand we're modifying AST
     // members but not the AST container.
     variable_buffer: ScopedBuffer<VariableId>,
     definition_buffer: ScopedBuffer<DefinitionId>,
     statement_buffer: ScopedBuffer<StatementId>,
     expression_buffer: ScopedBuffer<ExpressionId>,
     scope_buffer: ScopedBuffer<ScopeId>,
+}
 impl PassValidationLinking {
     pub(crate) fn new() -> Self {
         Self{
             in_sync: SynchronousStatementId::new_invalid(),
             in_while: WhileStatementId::new_invalid(),
             in_select_guard: SelectStatementId::new_invalid(),
             in_select_arm: 0,
             in_test_expr: StatementId::new_invalid(),
             in_binding_expr: BindingExpressionId::new_invalid(),
             in_binding_expr_lhs: false,
             cur_scope: ScopeId::new_invalid(),
             prev_stmt: StatementId::new_invalid(),
             expr_parent: ExpressionParent::None,
             proc_id: ProcedureDefinitionId::new_invalid(),
             proc_kind: ProcedureKind::Function,
             must_be_assignable: None,
             relative_pos_in_parent: 0,
             next_expr_index: 0,
             control_flow_stmts: Vec::with_capacity(BUFFER_INIT_CAP_SMALL),
             variable_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
             definition_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
             statement_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),
             expression_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),
             scope_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),
+        }
+    }
     fn reset_state(&mut self) {
         self.in_sync = SynchronousStatementId::new_invalid();
         self.in_while = WhileStatementId::new_invalid();
         self.in_select_guard = SelectStatementId::new_invalid();
         self.in_test_expr = StatementId::new_invalid();
         self.in_binding_expr = BindingExpressionId::new_invalid();
         self.in_binding_expr_lhs = false;
         self.cur_scope = ScopeId::new_invalid();
         self.proc_id = ProcedureDefinitionId::new_invalid();
         self.proc_kind = ProcedureKind::Function;
         self.prev_stmt = StatementId::new_invalid();
         self.expr_parent = ExpressionParent::None;
         self.must_be_assignable = None;
         self.relative_pos_in_parent = 0;
         self.next_expr_index = 0;
         self.control_flow_stmts.clear();
+    }
+}
 macro_rules! assign_then_erase_next_stmt {
     ($self:ident, $ctx:ident, $stmt_id:expr) => {
         if !$self.prev_stmt.is_invalid() {
             $ctx.heap[$self.prev_stmt].link_next($stmt_id);
             $self.prev_stmt = StatementId::new_invalid();
+        }
+    }
+}
 macro_rules! assign_and_replace_next_stmt {
     ($self:ident, $ctx:ident, $stmt_id:expr) => {
         if !$self.prev_stmt.is_invalid() {
             $ctx.heap[$self.prev_stmt].link_next($stmt_id);
+        }
         $self.prev_stmt = $stmt_id;
+    }
+}
 impl Visitor 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_id in section.iter_copied() {
             self.visit_definition(ctx, definition_id)?;
+        }
         section.forget();
         ctx.module_mut().phase = ModuleCompilationPhase::ValidatedAndLinked;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Definition visitors
     //--------------------------------------------------------------------------
     fn visit_procedure_definition(&mut self, ctx: &mut Ctx, id: ProcedureDefinitionId) -> VisitorResult {
         self.reset_state();
@@ @@ -532,482 +531,465 @@ impl Visitor for PassValidationLinking { @@
         // Check if "return" occurs within a function
         let stmt = &ctx.heap[id];
         if self.proc_kind != ProcedureKind::Function {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, stmt.span,
                 "return statements may only appear in function bodies"
             ));
+        }
         // If here then we are within a function
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         debug_assert_eq!(self.expr_parent, ExpressionParent::None);
         debug_assert_eq!(ctx.heap[id].expressions.len(), 1);
         self.expr_parent = ExpressionParent::Return(id);
         self.visit_expr(ctx, ctx.heap[id].expressions[0])?;
         self.expr_parent = ExpressionParent::None;
         Ok(())
+    }
     fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {
         self.control_flow_stmts.push(ControlFlowStatement{
             in_sync: self.in_sync,
             in_while: self.in_while,
             in_scope: self.cur_scope,
             statement: id.upcast(),
         });
         assign_then_erase_next_stmt!(self, ctx, id.upcast());
         Ok(())
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         // Make sure the new statement occurs inside a composite component
         if self.proc_kind != ProcedureKind::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;
         assign_and_replace_next_stmt!(self, ctx, id.upcast());
         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;
         assign_and_replace_next_stmt!(self, ctx, id.upcast());
         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 {
             // Look at us: lying through our teeth while providing error messages.
             ExpressionParent::Memory(_) => {},
             ExpressionParent::ExpressionStmt(_) => {},
             _ => {
                 let assignment_span = assignment_expr.full_span;
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, assignment_span,
                     "assignments are statements, and cannot be used in expressions"
                 ))
             },
+        }
         let left_expr_id = assignment_expr.left;
         let right_expr_id = assignment_expr.right;
         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.operator_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();
         // 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.full_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.full_span,
                 "nested binding expressions are not allowed"
             ).with_info_str_at_span(
                 &ctx.module().source, previous_expr.operator_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.full_span,
                     "only the logical-and operator (&&) may be applied to binding expressions"
                 ).with_info_str_at_span(
                     &ctx.module().source, parent_expr.operation_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.operator_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];
         if let Some(span) = self.must_be_assignable {
             // TODO: @Slicing
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "assignment to slices should be valid in the final language, but is currently not implemented"
             ));
+        }
         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] {
                         let field_span = field.identifier.span;
                         return Err(ParseError::new_error_str_at_span(
                             &ctx.module().source, field_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)
                     };
                     let literal_span = literal.parser_type.full_span;
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, literal_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();
@@ @@ -1019,474 +1001,468 @@ impl Visitor for PassValidationLinking { @@
                 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.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.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.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) | Literal::Tuple(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"
             ))
+        }
         let upcast_id = id.upcast();
         let old_expr_parent = self.expr_parent;
         cast_expr.parent = old_expr_parent;
         cast_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         // Recurse into the thing that we're casting
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         let subject_id = cast_expr.subject;
         self.visit_expr(ctx, subject_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         let call_expr = &ctx.heap[id];
         if let Some(span) = self.must_be_assignable {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, span, "cannot assign to the result from a call expression"
             ))
+        }
         // Check whether the method is allowed to be called within the code's
         // context (in sync, definition type, etc.)
         let mut expecting_wrapping_new_stmt = false;
         let mut expecting_primitive_def = false;
         let mut expecting_wrapping_sync_stmt = false;
         let mut expecting_no_select_stmt = false;
         match call_expr.method {
             Method::Get => {
                 expecting_primitive_def = true;
                 expecting_wrapping_sync_stmt = true;
                 if !self.in_select_guard.is_invalid() {
                     // In a select guard. Take the argument (i.e. the port we're
                     // retrieving from) and add it to the list of involved ports
                     // of the guard
                     if call_expr.arguments.len() == 1 {
                         // We're checking the number of arguments later, for now
                         // assume it is correct.
                         let argument = call_expr.arguments[0];
                         let select_stmt = &mut ctx.heap[self.in_select_guard];
                         let select_case = &mut select_stmt.cases[self.in_select_arm as usize];
                         select_case.involved_ports.push((id, argument));
+                    }
+                }
             },
             Method::Put => {
                 expecting_primitive_def = true;
                 expecting_wrapping_sync_stmt = true;
                 expecting_no_select_stmt = true;
             },
             Method::Fires => {
                 expecting_primitive_def = true;
                 expecting_wrapping_sync_stmt = true;
             },
             Method::Create => {},
             Method::Length => {},
             Method::Assert => {
                 expecting_wrapping_sync_stmt = true;
                 expecting_no_select_stmt = true;
                 if self.proc_kind == ProcedureKind::Function {
                     let call_span = call_expr.func_span;
                     return Err(ParseError::new_error_str_at_span(
                         &ctx.module().source, call_span,
                         "assert statement may only occur in components"
                     ));
+                }
             },
             Method::Print => {},
             Method::SelectStart
             | Method::SelectRegisterCasePort
             | Method::SelectWait => unreachable!(), // not usable by programmer directly
-            Method::UserProcedure => {}
+            Method::UserFunction => {}
             Method::UserComponent => {
                 expecting_wrapping_new_stmt = true;
             },
+        }
         let call_expr = &mut ctx.heap[id];
         fn get_span_and_name<'a>(ctx: &'a Ctx, id: CallExpressionId) -> (InputSpan, String) {
             let call = &ctx.heap[id];
             let span = call.func_span;
             let name = String::from_utf8_lossy(ctx.module().source.section_at_span(span)).to_string();
             return (span, name);
+        }
         if expecting_primitive_def {
             if self.proc_kind != ProcedureKind::Primitive {
                 let (call_span, func_name) = get_span_and_name(ctx, id);
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, call_span,
                     format!("a call to '{}' may only occur in primitive component definitions", func_name)
                 ));
+            }
+        }
         if expecting_wrapping_sync_stmt {
             if self.in_sync.is_invalid() {
                 let (call_span, func_name) = get_span_and_name(ctx, id);
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, call_span,
                     format!("a call to '{}' may only occur inside synchronous blocks", func_name)
                 ))
+            }
+        }
         if expecting_no_select_stmt {
             if !self.in_select_guard.is_invalid() {
                 let (call_span, func_name) = get_span_and_name(ctx, id);
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, call_span,
                     format!("a call to '{}' may not occur in a select statement's guard", func_name)
                 ));
+            }
+        }
         if expecting_wrapping_new_stmt {
             if !self.expr_parent.is_new() {
                 let call_span = call_expr.func_span;
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, call_span,
                     "cannot call a component, it can only be instantiated by using 'new'"
                 ));
+            }
         } else {
             if self.expr_parent.is_new() {
                 let call_span = call_expr.func_span;
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, call_span,
                     "only components can be instantiated, this is a function"
                 ));
+            }
+        }
         // Check the number of arguments
         let call_definition = ctx.types.get_base_definition(&call_expr.procedure.upcast()).unwrap();
         let num_expected_args = match &call_definition.definition {
             DefinedTypeVariant::Procedure(definition) => definition.arguments.len(),
             _ => unreachable!(),
         };
         let num_provided_args = call_expr.arguments.len();
         if num_provided_args != num_expected_args {
             let argument_text = if num_expected_args == 1 { "argument" } else { "arguments" };
             let call_span = call_expr.full_span;
             return Err(ParseError::new_error_at_span(
                 &ctx.module().source, call_span, format!(
                     "expected {} {}, but {} were provided",
                     num_expected_args, argument_text, num_provided_args
+                )
             ));
+        }
         // Recurse into all of the arguments and set the expression's parent
         let upcast_id = id.upcast();
         let section = self.expression_buffer.start_section_initialized(&call_expr.arguments);
         let old_expr_parent = self.expr_parent;
         call_expr.parent = old_expr_parent;
         call_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         for arg_expr_idx in 0..section.len() {
             let arg_expr_id = section[arg_expr_idx];
             self.expr_parent = ExpressionParent::Expression(upcast_id, arg_expr_idx as u32);
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         section.forget();
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         let var_expr = &ctx.heap[id];
         // Check if declaration was already resolved (this occurs for the
         // variable expr that is on the LHS of the assignment expr that is
         // associated with a variable declaration)
         let mut variable_id = var_expr.declaration;
         let mut is_binding_target = false;
         // Otherwise try to find it
         if variable_id.is_none() {
             variable_id = self.find_variable(ctx, self.relative_pos_in_parent, &var_expr.identifier);
+        }
         // Otherwise try to see if is a variable introduced by a binding expr
         let variable_id = if let Some(variable_id) = variable_id {
             variable_id
         } else {
             if self.in_binding_expr.is_invalid() || !self.in_binding_expr_lhs {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, var_expr.identifier.span, "unresolved variable"
                 ));
+            }
             // This is a binding variable, but it may only appear in very
             // specific locations.
             let is_valid_binding = match self.expr_parent {
                 ExpressionParent::Expression(expr_id, idx) => {
                     match &ctx.heap[expr_id] {
                         Expression::Binding(_binding_expr) => {
                             // Nested binding is disallowed, and because of
                             // the check above we know we're directly at the
                             // LHS of the binding expression
                             debug_assert_eq!(_binding_expr.this, self.in_binding_expr);
                             debug_assert_eq!(idx, 0);
                             true
+                        }
                         Expression::Literal(lit_expr) => {
                             // Only struct, unions, tuples and arrays can
                             // have subexpressions, so we're always fine
                             dbg_code!({
                                 match lit_expr.value {
                                     Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) | Literal::Tuple(_) => {},
                                     _ => unreachable!(),
+                                }
                             });
                             true
                         },
                         _ => false,
+                    }
                 },
                 _ => {
                     false
+                }
             };
             if !is_valid_binding {
                 let binding_expr = &ctx.heap[self.in_binding_expr];
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, var_expr.identifier.span,
                     "illegal location for binding variable: binding variables may only be nested under a binding expression, or a struct, union or array literal"
                 ).with_info_at_span(
                     &ctx.module().source, binding_expr.operator_span, format!(
                         "'{}' was interpreted as a binding variable because the variable is not declared and it is nested under this binding expression",
                         var_expr.identifier.value.as_str()
+                    )
                 ));
+            }
             // By now we know that this is a valid binding expression. Given
             // that a binding expression must be nested under an if/while
             // statement, we now add the variable to the scope associated with
             // that statement.
             let bound_identifier = var_expr.identifier.clone();
             let bound_variable_id = ctx.heap.alloc_variable(|this| Variable {
                 this,
                 kind: VariableKind::Binding,
                 parser_type: ParserType {
                     elements: vec![ParserTypeElement {
                         element_span: bound_identifier.span,
                         variant: ParserTypeVariant::Inferred
                     }],
                     full_span: bound_identifier.span
                 },
                 identifier: bound_identifier,
                 relative_pos_in_parent: 0,
                 unique_id_in_scope: -1,
             });
             let scope_id = match &ctx.heap[self.in_test_expr] {
                 Statement::If(stmt) => stmt.true_case.scope,
                 Statement::While(stmt) => stmt.scope,
                 _ => unreachable!(),
             };
             self.checked_at_single_scope_add_local(ctx, scope_id, -1, bound_variable_id)?; // add at -1 such that first statement can find the variable if needed
             is_binding_target = true;
             bound_variable_id
         };
         let var_expr = &mut ctx.heap[id];
         var_expr.declaration = Some(variable_id);
         var_expr.used_as_binding_target = is_binding_target;
         var_expr.parent = self.expr_parent;
         var_expr.unique_id_in_definition = self.next_expr_index;
         self.next_expr_index += 1;
         Ok(())
+    }
+}
 impl PassValidationLinking {
     //--------------------------------------------------------------------------
     // Special traversal
     //--------------------------------------------------------------------------
     /// Pushes a new scope associated with a particular statement. If that
     /// statement already has an associated scope (i.e. scope associated with
     /// sync statement or select statement's arm) then we won't do anything.
     /// In all cases the caller must call `pop_statement_scope` with the scope
     /// and relative scope position returned by this function.
     fn push_scope(&mut self, ctx: &mut Ctx, is_top_level_scope: bool, pushed_scope_id: ScopeId) -> (ScopeId, i32) {
         // Set the properties of the pushed scope (it is already created during
         // AST construction, but most values are not yet set to their correct
         // values)
         let old_scope_id = self.cur_scope;
         let scope = &mut ctx.heap[pushed_scope_id];
         if !is_top_level_scope {
             scope.parent = Some(old_scope_id);
+        }
         scope.relative_pos_in_parent = self.relative_pos_in_parent;
         let old_relative_pos = self.relative_pos_in_parent;
         self.relative_pos_in_parent = 0;
         // Link up scopes
         if !is_top_level_scope {
             let old_scope = &mut ctx.heap[old_scope_id];
             old_scope.nested.push(pushed_scope_id);
+        }
         // Set as current traversal scope, then return old scope
         self.cur_scope = pushed_scope_id;
         return (old_scope_id, old_relative_pos)
+    }
     fn pop_scope(&mut self, scope_to_restore: (ScopeId, i32)) {
         self.cur_scope = scope_to_restore.0;
         self.relative_pos_in_parent = scope_to_restore.1;
+    }
     fn resolve_pending_control_flow_targets(&mut self, ctx: &mut Ctx) -> Result<(), ParseError> {
         for entry in &self.control_flow_stmts {
             let stmt = &ctx.heap[entry.statement];
             match stmt {
                 Statement::Break(stmt) => {
                     let stmt_id = stmt.this;
                     let target_while_id = Self::resolve_break_or_continue_target(ctx, entry, stmt.span, &stmt.label)?;
                     let target_while_stmt = &ctx.heap[target_while_id];
                     let target_end_while_id = target_while_stmt.end_while;
                     debug_assert!(!target_end_while_id.is_invalid());
                     let break_stmt = &mut ctx.heap[stmt_id];
                     break_stmt.target = target_end_while_id;
                 },
                 Statement::Continue(stmt) => {
                     let stmt_id = stmt.this;
                     let target_while_id = Self::resolve_break_or_continue_target(ctx, entry, stmt.span, &stmt.label)?;
                     let continue_stmt = &mut ctx.heap[stmt_id];
                     continue_stmt.target = target_while_id;
                 },
                 Statement::Goto(stmt) => {
                     let stmt_id = stmt.this;
                     let target_id = Self::find_label(entry.in_scope, ctx, &stmt.label)?;
                     let target_stmt = &ctx.heap[target_id];
                     if entry.in_sync != target_stmt.in_sync {
                         // Nested sync not allowed. And goto can only go to
                         // outer scopes, so we must be escaping from a sync.
                         debug_assert!(target_stmt.in_sync.is_invalid());    // target not in sync
                         debug_assert!(!entry.in_sync.is_invalid()); // but the goto is in sync
                         let goto_stmt = &ctx.heap[stmt_id];
                         let sync_stmt = &ctx.heap[entry.in_sync];
                         return Err(
                             ParseError::new_error_str_at_span(&ctx.module().source, goto_stmt.span, "goto may not escape the surrounding synchronous block")
                             .with_info_str_at_span(&ctx.module().source, target_stmt.label.span, "this is the target of the goto statement")
                             .with_info_str_at_span(&ctx.module().source, sync_stmt.span, "which will jump past this statement")
                         );
+                    }
                     let goto_stmt = &mut ctx.heap[stmt_id];
                     goto_stmt.target = target_id;
                 },
                 _ => unreachable!("cannot resolve control flow target for {:?}", stmt),
+            }
+        }
         return Ok(())
+    }

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -135,259 +135,257 @@ pub struct EnumVariant { @@
 /// will reserve enough space on the stack for all union variants that do not
 /// cause "type loops" (i.e. a union `A` with a variant containing a struct
 /// `B`). And we will reserve enough space on the heap (and store a pointer in
 /// the union) for all variants which do cause type loops (i.e. a union `A`
 /// with a variant to a struct `B` that contains the union `A` again).
 pub struct UnionType {
     pub variants: Vec<UnionVariant>,
     pub tag_type: ConcreteType,
     pub tag_size: usize,
+}
 pub struct UnionVariant {
     pub identifier: Identifier,
     pub embedded: Vec<ParserType>, // zero-length does not have embedded values
     pub tag_value: i64,
+}
 /// `StructType` is a generic C-like struct type (or record type, or product
 /// type) type.
 pub struct StructType {
     pub fields: Vec<StructField>,
+}
 pub struct StructField {
     pub identifier: Identifier,
     pub parser_type: ParserType,
+}
 /// `ProcedureType` is the signature of a procedure/component
 pub struct ProcedureType {
     pub kind: ProcedureKind,
     pub return_type: Option<ParserType>,
     pub arguments: Vec<ProcedureArgument>,
+}
 pub struct ProcedureArgument {
     identifier: Identifier,
     parser_type: ParserType,
+}
 /// Represents the data associated with a single expression after type inference
 /// for a monomorph (or just the normal expression types, if dealing with a
 /// non-polymorphic function/component).
 pub struct MonomorphExpression {
     // The output type of the expression. Note that for a function it is not the
     // function's signature but its return type
     pub(crate) expr_type: ConcreteType,
     // Has multiple meanings: the field index for select expressions, the
     // monomorph index for polymorphic function calls or literals. Negative
     // values are never used, but used to catch programming errors.
     pub(crate) field_or_monomorph_idx: i32,
     pub(crate) type_id: TypeId,
+}
 //------------------------------------------------------------------------------
 // Type monomorph storage
 //------------------------------------------------------------------------------
 pub(crate) enum MonoTypeVariant {
     Builtin, // no extra data, added manually in compiler initialization code
     Enum, // no extra data
     Struct(StructMonomorph),
     Union(UnionMonomorph),
     Procedure(ProcedureMonomorph), // functions, components
     Tuple(TupleMonomorph),
+}
 impl MonoTypeVariant {
     fn as_struct_mut(&mut self) -> &mut StructMonomorph {
         match self {
             MonoTypeVariant::Struct(v) => v,
             _ => unreachable!(),
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionMonomorph {
         match self {
             MonoTypeVariant::Union(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_union_mut(&mut self) -> &mut UnionMonomorph {
         match self {
             MonoTypeVariant::Union(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_tuple_mut(&mut self) -> &mut TupleMonomorph {
         match self {
             MonoTypeVariant::Tuple(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_procedure(&self) -> &ProcedureMonomorph {
+    pub(crate) fn as_procedure(&self) -> &ProcedureMonomorph {
         match self {
             MonoTypeVariant::Procedure(v) => v,
             _ => unreachable!(),
+        }
+    }
     fn as_procedure_mut(&mut self) -> &mut ProcedureMonomorph {
         match self {
             MonoTypeVariant::Procedure(v) => v,
             _ => unreachable!(),
+        }
+    }
+}
 /// Struct monomorph
 pub struct StructMonomorph {
     pub fields: Vec<StructMonomorphField>,
+}
 pub struct StructMonomorphField {
     pub type_id: TypeId,
     concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Union monomorph
 pub struct UnionMonomorph {
     pub variants: Vec<UnionMonomorphVariant>,
     pub tag_size: usize, // copied from `UnionType` upon monomorph construction.
     // note that the stack size is in the `TypeMonomorph` struct. This size and
     // alignment will include the size of the union tag.
     //
     // heap_size contains the allocated size of the union in the case it
     // is used to break a type loop. If it is 0, then it doesn't require
     // allocation and lives entirely on the stack.
     pub heap_size: usize,
     pub heap_alignment: usize,
+}
 pub struct UnionMonomorphVariant {
     pub lives_on_heap: bool,
     pub embedded: Vec<UnionMonomorphEmbedded>,
+}
 pub struct UnionMonomorphEmbedded {
     pub type_id: TypeId,
     concrete_type: ConcreteType,
     // Note that the meaning of the offset (and alignment) depend on whether or
     // not the variant lives on the stack/heap. If it lives on the stack then
     // they refer to the offset from the start of the union value (so the first
     // embedded type lives at a non-zero offset, because the union tag sits in
     // the front). If it lives on the heap then it refers to the offset from the
     // allocated memory region (so the first embedded type lives at a 0 offset).
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Procedure (functions and components of all possible types) monomorph. Also
 /// stores the expression type data from the typechecking/inferencing pass.
 pub struct ProcedureMonomorph {
     // Expression data for one particular monomorph
     pub arg_types: Vec<ConcreteType>,
     pub expr_data: Vec<MonomorphExpression>,
     pub monomorph_index: u32,
+}
 /// Tuple monomorph. Again a kind of exception because one cannot define a named
 /// tuple type containing explicit polymorphic variables. But again: we need to
 /// store size/offset/alignment information, so we do it here.
 pub struct TupleMonomorph {
     pub members: Vec<TupleMonomorphMember>
+}
 pub struct TupleMonomorphMember {
     pub type_id: TypeId,
     concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub offset: usize,
+}
 /// Generic unique type ID. Every monomorphed type and every non-polymorphic
 /// type will have one of these associated with it.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct TypeId(i64);
 impl TypeId {
     pub(crate) fn new_invalid() -> Self {
         return Self(-1);
+    }
+}
 /// A monomorphed type (or non-polymorphic type's) memory layout and information
 /// regarding associated types (like a struct's field type).
 pub struct MonoType {
     pub type_id: TypeId,
     pub concrete_type: ConcreteType,
     pub size: usize,
     pub alignment: usize,
     pub(crate) variant: MonoTypeVariant
+}
 impl MonoType {
     #[inline]
     fn new_empty(type_id: TypeId, concrete_type: ConcreteType, variant: MonoTypeVariant) -> Self {
         return Self {
             type_id, concrete_type,
             size: 0,
             alignment: 0,
             variant,
+        }
+    }
     /// Little internal helper function as a reminder: if alignment is 0, then
     /// the size/alignment are not actually computed yet!
     #[inline]
     fn get_size_alignment(&self) -> Option<(usize, usize)> {
         if self.alignment == 0 {
             return None
         } else {
             return Some((self.size, self.alignment));
+        }
+    }
+}
 /// Special structure that acts like the lookup key for `ConcreteType` instances
 /// that have already been added to the type table before.
 #[derive(Clone)]
 struct MonoSearchKey {
     // Uses bitflags to denote when parts between search keys should match and
     // whether they should be checked. Needs to have a system like this to
     // accommodate tuples.
     parts: Vec<(u8, ConcreteTypePart)>,
     change_bit: u8,
+}
 impl MonoSearchKey {
     const KEY_IN_USE: u8 = 0x01;
     const KEY_CHANGE_BIT: u8 = 0x02;
     fn with_capacity(capacity: usize) -> Self {
         return MonoSearchKey{
             parts: Vec::with_capacity(capacity),
             change_bit: 0,
         };
+    }
     /// Sets the search key based on a single concrete type and its polymorphic
     /// variables.
     fn set(&mut self, concrete_type_parts: &[ConcreteTypePart], poly_var_in_use: &[PolymorphicVariable]) {
         self.set_top_type(concrete_type_parts[0]);
         let mut poly_var_index = 0;
         for subtype in ConcreteTypeIter::new(concrete_type_parts, 0) {
             let in_use = poly_var_in_use[poly_var_index].is_in_use;
             poly_var_index += 1;
             self.push_subtype(subtype, in_use);
+        }
         debug_assert_eq!(poly_var_index, poly_var_in_use.len());
@@ @@ -611,203 +609,202 @@ impl TypeTable { @@
     pub(crate) fn build_base_types(&mut self, modules: &mut [Module], ctx: &mut PassCtx) -> Result<(), ParseError> {
         // Make sure we're allowed to cast root_id to index into ctx.modules
         debug_assert!(modules.iter().all(|m| m.phase >= ModuleCompilationPhase::DefinitionsParsed));
         debug_assert!(self.definition_lookup.is_empty());
         dbg_code!({
             for (index, module) in modules.iter().enumerate() {
                 debug_assert_eq!(index, module.root_id.index as usize);
+            }
         });
         // Use context to guess hashmap size of the base types
         let reserve_size = ctx.heap.definitions.len();
         self.definition_lookup.reserve(reserve_size);
         // Resolve all base types
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let definition = &ctx.heap[definition_id];
             match definition {
                 Definition::Enum(_) => self.build_base_enum_definition(modules, ctx, definition_id)?,
                 Definition::Union(_) => self.build_base_union_definition(modules, ctx, definition_id)?,
                 Definition::Struct(_) => self.build_base_struct_definition(modules, ctx, definition_id)?,
                 Definition::Procedure(_) => self.build_base_procedure_definition(modules, ctx, definition_id)?,
+            }
+        }
         debug_assert_eq!(self.definition_lookup.len(), reserve_size, "mismatch in reserved size of type table");
         for module in modules.iter_mut() {
             module.phase = ModuleCompilationPhase::TypesAddedToTable;
+        }
         // Go through all types again, lay out all types that are not
         // polymorphic. This might cause us to lay out monomorphized polymorphs
         // if these were member types of non-polymorphic types.
         for definition_idx in 0..ctx.heap.definitions.len() {
             let definition_id = ctx.heap.definitions.get_id(definition_idx);
             let poly_type = self.definition_lookup.get(&definition_id).unwrap();
             if !poly_type.definition.is_data_type() || !poly_type.poly_vars.is_empty() {
                 continue;
+            }
             // If here then the type is a data type without polymorphic
             // variables, but we might have instantiated it already, so:
             let concrete_parts = [ConcreteTypePart::Instance(definition_id, 0)];
             self.mono_search_key.set(&concrete_parts, &[]);
             let type_id = self.mono_type_lookup.get(&self.mono_search_key);
             if type_id.is_none() {
                 self.detect_and_resolve_type_loops_for(
                     modules, ctx.heap,
                     ConcreteType{
                         parts: vec![ConcreteTypePart::Instance(definition_id, 0)]
                     },
                 )?;
                 self.lay_out_memory_for_encountered_types(ctx.arch);
+            }
+        }
         Ok(())
+    }
     /// Retrieves base definition from type table. We must be able to retrieve
     /// it as we resolve all base types upon type table construction (for now).
     /// However, in the future we might do on-demand type resolving, so return
     /// an option anyway
     #[inline]
     pub(crate) fn get_base_definition(&self, definition_id: &DefinitionId) -> Option<&DefinedType> {
         self.definition_lookup.get(&definition_id)
+    }
     /// Returns the index into the monomorph type array if the procedure type
     /// already has a (reserved) monomorph.
     #[inline]
     pub(crate) fn get_procedure_monomorph_type_id(&self, definition_id: &DefinitionId, type_parts: &[ConcreteTypePart]) -> Option<TypeId> {
         // Cannot use internal search key due to mutability issues. But this
         // method should end up being deprecated at some point anyway.
         debug_assert_eq!(get_concrete_type_definition(type_parts).unwrap(), *definition_id);
         let base_type = self.definition_lookup.get(definition_id).unwrap();
         let mut search_key = MonoSearchKey::with_capacity(type_parts.len());
         search_key.set(type_parts, &base_type.poly_vars);
         return self.mono_type_lookup.get(&search_key).copied();
+    }
     #[inline]
     pub(crate) fn get_monomorph(&self, type_id: TypeId) -> &MonoType {
         return &self.mono_types[type_id.0 as usize];
+    }
     /// Reserves space for a monomorph of a polymorphic procedure. The index
     /// will point into a (reserved) slot of the array of expression types. The
     /// monomorph may NOT exist yet (because the reservation implies that we're
     /// going to be performing typechecking on it, and we don't want to
     /// check the same monomorph twice)
     pub(crate) fn reserve_procedure_monomorph_type_id(&mut self, definition_id: &DefinitionId, concrete_type: ConcreteType) -> TypeId {
+    pub(crate) fn reserve_procedure_monomorph_type_id(&mut self, definition_id: &DefinitionId, concrete_type: ConcreteType, monomorph_index: u32) -> TypeId {
         debug_assert_eq!(get_concrete_type_definition(&concrete_type.parts).unwrap(), *definition_id);
         let type_id = TypeId(self.mono_types.len() as i64);
         let base_type = self.definition_lookup.get_mut(definition_id).unwrap();
         self.mono_search_key.set(&concrete_type.parts, &base_type.poly_vars);
         debug_assert!(!self.mono_type_lookup.contains_key(&self.mono_search_key));
         self.mono_type_lookup.insert(self.mono_search_key.clone(), type_id);
         self.mono_types.push(MonoType::new_empty(type_id, concrete_type, MonoTypeVariant::Procedure(ProcedureMonomorph{
             arg_types: Vec::new(),
             expr_data: Vec::new(),
             monomorph_index,
         })));
         return type_id;
+    }
     /// Adds a builtin type to the type table. As this is only called by the
     /// compiler during setup we assume it cannot fail.
     pub(crate) fn add_builtin_type(&mut self, concrete_type: ConcreteType, poly_vars: &[PolymorphicVariable], size: usize, alignment: usize) -> TypeId {
         self.mono_search_key.set(&concrete_type.parts, poly_vars);
         debug_assert!(!self.mono_type_lookup.contains_key(&self.mono_search_key));
         debug_assert_ne!(alignment, 0);
         let type_id = TypeId(self.mono_types.len() as i64);
         self.mono_type_lookup.insert(self.mono_search_key.clone(), type_id);
         self.mono_types.push(MonoType{
             type_id,
             concrete_type,
             size,
             alignment,
             variant: MonoTypeVariant::Builtin,
         });
         return type_id;
+    }
     /// Adds a monomorphed type to the type table. If it already exists then the
     /// previous entry will be used.
     pub(crate) fn add_monomorphed_type(
         &mut self, modules: &[Module], heap: &Heap, arch: &TargetArch, concrete_type: ConcreteType
     ) -> Result<TypeId, ParseError> {
         let poly_vars = match get_concrete_type_definition(&concrete_type.parts) {
             Some(definition_id) => {
                 let definition = self.definition_lookup.get(&definition_id).unwrap();
                 definition.poly_vars.as_slice()
             },
             None => {
                 &[]
+            }
         };
         // Check if the concrete type was already added
         self.mono_search_key.set(&concrete_type.parts, poly_vars);
         if let Some(type_id) = self.mono_type_lookup.get(&self.mono_search_key) {
             return Ok(*type_id);
+        }
         // Concrete type needs to be added
         self.detect_and_resolve_type_loops_for(modules, heap, concrete_type)?;
         let type_id = self.encountered_types[0].type_id;
         self.lay_out_memory_for_encountered_types(arch);
         return Ok(type_id);
+    }
     //--------------------------------------------------------------------------
     // Building base types
     //--------------------------------------------------------------------------
     /// Builds the base type for an enum. Will not compute byte sizes
     fn build_base_enum_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.definition_lookup.contains_key(&definition_id), "base enum already built");
         let definition = ctx.heap[definition_id].as_enum();
         let root_id = definition.defined_in;
         // Determine enum variants
         let mut enum_value = -1;
         let mut variants = Vec::with_capacity(definition.variants.len());
         for variant in &definition.variants {
             if enum_value == i64::MAX {
                 let source = &modules[definition.defined_in.index as usize].source;
                 return Err(ParseError::new_error_str_at_span(
                     source, variant.identifier.span,
                     "this enum variant has an integer value that is too large"
                 ));
+            }
             enum_value += 1;
             if let EnumVariantValue::Integer(explicit_value) = variant.value {
                 enum_value = explicit_value;
+            }
             variants.push(EnumVariant{
                 identifier: variant.identifier.clone(),
                 value: enum_value,
             });
+        }
         // Determine tag size
         let mut min_enum_value = 0;
         let mut max_enum_value = 0;
         if !variants.is_empty() {
             min_enum_value = variants[0].value;
             max_enum_value = variants[0].value;
             for variant in variants.iter().skip(1) {
                 min_enum_value = min_enum_value.min(variant.value);
                 max_enum_value = max_enum_value.max(variant.value);

src/protocol/tests/utils.rs

➞

Show inline comments

@@ @@ -655,229 +655,234 @@ impl<'a> FunctionTester<'a> { @@
                     false,
                     "[{}] Expected call to succeed, but got {:?} for {}",
                     self.ctx.test_name, err, self.assert_postfix()
+                )
+            }
+        }
         if let Some(expected_result) = expected_result {
             debug_assert!(expected_result.get_heap_pos().is_none(), "comparing against heap thingamajigs is not yet implemented");
             assert!(
                 value::apply_equality_operator(&prompt.store, &prompt.store.stack[0], &expected_result),
                 "[{}] Result from call was {:?}, but expected {:?} for {}",
                 self.ctx.test_name, &prompt.store.stack[0], &expected_result, self.assert_postfix()
+            )
+        }
         self
+    }
     // Keeping this simple for now, will likely change
     pub(crate) fn call_err(self, expected_result: &str) -> Self {
         let (_, result) = self.eval_until_end();
         match result {
             Ok(_) => {
                 assert!(
                     false,
                     "[{}] Expected an error, but evaluation finished successfully for {}",
                     self.ctx.test_name, self.assert_postfix()
                 );
             },
             Err(err) => {
                 println!("DEBUG: Formatted evaluation error:\n{}", err);
                 debug_assert_eq!(err.statements.len(), 1);
                 assert!(
                     err.statements[0].message.contains(&expected_result),
                     "[{}] Expected error message to contain '{}', but it was '{}' for {}",
                     self.ctx.test_name, expected_result, err.statements[0].message, self.assert_postfix()
                 );
+            }
+        }
         self
+    }
     fn eval_until_end(&self) -> (Prompt, Result<EvalContinuation, EvalError>) {
         use crate::protocol::*;
         // Assuming the function is not polymorphic
         let definition_id = self.def.this;
         let func_type = [ConcreteTypePart::Function(definition_id, 0)];
         let mono_index = self.ctx.types.get_procedure_monomorph_type_id(&definition_id.upcast(), &func_type).unwrap();
         let mut prompt = Prompt::new(&self.ctx.types, &self.ctx.heap, definition_id, mono_index, ValueGroup::new_stack(Vec::new()));
         let mut call_context = FakeRunContext{};
         loop {
             let result = prompt.step(&self.ctx.types, &self.ctx.heap, &self.ctx.modules, &mut call_context);
             match result {
                 Ok(EvalContinuation::Stepping) => {},
                 _ => return (prompt, result),
+            }
+        }
+    }
     fn assert_postfix(&self) -> String {
         format!("Function{{ name: {} }}", self.def.identifier.value.as_str())
+    }
+}
 pub(crate) struct VariableTester<'a> {
     ctx: TestCtx<'a>,
     definition_id: DefinitionId,
     variable: &'a Variable,
     var_expr: &'a VariableExpression,
+}
 impl<'a> VariableTester<'a> {
     fn new(
         ctx: TestCtx<'a>, definition_id: DefinitionId, variable: &'a Variable, var_expr: &'a VariableExpression
     ) -> Self {
         Self{ ctx, definition_id, variable, var_expr }
+    }
     pub(crate) fn assert_parser_type(self, expected: &str) -> Self {
         let mut serialized = String::new();
         serialize_parser_type(&mut serialized, self.ctx.heap, &self.variable.parser_type);
         assert_eq!(
             expected, &serialized,
             "[{}] Expected parser type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_concrete_type(self, expected: &str) -> Self {
         // Lookup concrete type in type table
         let mono_data = get_procedure_monomorph(&self.ctx.heap, &self.ctx.types, self.definition_id);
         let concrete_type = &mono_data.expr_data[self.var_expr.unique_id_in_definition as usize].expr_type;
         let mono_proc = get_procedure_monomorph(&self.ctx.heap, &self.ctx.types, self.definition_id);
         let mono_index = mono_proc.monomorph_index;
         let mono_data = &self.ctx.heap[self.definition_id].as_procedure().monomorphs[mono_index as usize];
         let expr_info = &mono_data.expr_info[self.var_expr.type_index as usize];
         let concrete_type = &self.ctx.types.get_monomorph(expr_info.type_id).concrete_type;
         // Serialize and check
         let serialized = concrete_type.display_name(self.ctx.heap);
         assert_eq!(
             expected, &serialized,
             "[{}] Expected concrete type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         format!("Variable{{ name: {} }}", self.variable.identifier.value.as_str())
+    }
+}
 pub(crate) struct ExpressionTester<'a> {
     ctx: TestCtx<'a>,
     definition_id: DefinitionId, // of the enclosing function/component
     expr: &'a Expression
+}
 impl<'a> ExpressionTester<'a> {
     fn new(
         ctx: TestCtx<'a>, definition_id: DefinitionId, expr: &'a Expression
     ) -> Self {
         Self{ ctx, definition_id, expr }
+    }
     pub(crate) fn assert_concrete_type(self, expected: &str) -> Self {
         // Lookup concrete type
         let mono_data = get_procedure_monomorph(&self.ctx.heap, &self.ctx.types, self.definition_id);
         let expr_index = self.expr.get_unique_id_in_definition();
         let concrete_type = &mono_data.expr_data[expr_index as usize].expr_type;
         let mono_proc = get_procedure_monomorph(&self.ctx.heap, &self.ctx.types, self.definition_id);
         let mono_index = mono_proc.monomorph_index;
         let mono_data = &self.ctx.heap[self.definition_id].as_procedure().monomorphs[mono_index as usize];
         let expr_info = &mono_data.expr_info[self.var_expr.type_index as usize];
         let concrete_type = &self.ctx.types.get_monomorph(expr_info.type_id).concrete_type;
         // Serialize and check type
         let serialized = concrete_type.display_name(self.ctx.heap);
         assert_eq!(
             expected, &serialized,
             "[{}] Expected concrete type '{}', but got '{}' for {}",
             self.ctx.test_name, expected, &serialized, self.assert_postfix()
         );
         self
+    }
     fn assert_postfix(&self) -> String {
         format!(
             "Expression{{ debug: {:?} }}",
             self.expr
+        )
+    }
+}
 fn get_procedure_monomorph<'a>(heap: &Heap, types: &'a TypeTable, definition_id: DefinitionId) -> &'a ProcedureMonomorph {
     let ast_definition = heap[definition_id].as_procedure();
     let func_type = if ast_definition.kind == ProcedureKind::Function {
         [ConcreteTypePart::Function(ast_definition.this, 0)]
     } else {
         [ConcreteTypePart::Component(ast_definition.this, 0)]
     };
     let mono_index = types.get_procedure_monomorph_type_id(&definition_id, &func_type).unwrap();
     let mono_data = types.get_procedure_monomorph(mono_index);
     mono_data
+}
 //------------------------------------------------------------------------------
 // Interface for failed compilation
 //------------------------------------------------------------------------------
 pub(crate) struct AstErrTester {
     test_name: String,
     error: ParseError,
+}
 impl AstErrTester {
     fn new(test_name: String, error: ParseError) -> Self {
         Self{ test_name, error }
+    }
     pub(crate) fn error<F: Fn(ErrorTester)>(&self, f: F) {
         // Maybe multiple errors will be supported in the future
         let tester = ErrorTester{ test_name: &self.test_name, error: &self.error };
         f(tester)
+    }
+}
 //------------------------------------------------------------------------------
 // Utilities for failed compilation
 //------------------------------------------------------------------------------
 pub(crate) struct ErrorTester<'a> {
     test_name: &'a str,
     error: &'a ParseError,
+}
 impl<'a> ErrorTester<'a> {
     pub(crate) fn assert_num(self, num: usize) -> Self {
         assert_eq!(
             num, self.error.statements.len(),
             "[{}] expected error to consist of '{}' parts, but encountered '{}' for {}",
             self.test_name, num, self.error.statements.len(), self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_ctx_has(self, idx: usize, msg: &str) -> Self {
         assert!(
             self.error.statements[idx].context.contains(msg),
             "[{}] expected error statement {}'s context to contain '{}' for {}",
             self.test_name, idx, msg, self.assert_postfix()
         );
         self
+    }
     pub(crate) fn assert_msg_has(self, idx: usize, msg: &str) -> Self {
         assert!(
             self.error.statements[idx].message.contains(msg),
             "[{}] expected error statement {}'s message to contain '{}' for {}",
             self.test_name, idx, msg, self.assert_postfix()
         );
         self
+    }
     /// Seeks the index of the pattern in the context message, then checks if

0 comments (0 inline, 0 general)