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

Changeset - a82fb2b1f7f9

Parent rev.

Child rev.

[Not reviewed]

0 5 0

MH - 4 years ago 2021-03-14 18:23:45
contact@maxhenger.nl

WIP on type inference

5 files changed with 347 insertions and 42 deletions:

src/protocol/ast.rs

src/protocol/parser/type_resolver.rs

200

src/protocol/parser/type_table.rs

src/protocol/parser/visitor.rs

src/protocol/parser/visitor_linker.rs

130

0 comments (0 inline, 0 general)

src/protocol/ast.rs

➞

Show inline comments

@@ @@ -928,192 +928,194 @@ impl Field { @@
+}
 #[derive(Debug, Clone, Copy, serde::Serialize, serde::Deserialize)]
 pub enum Scope {
     Definition(DefinitionId),
     Regular(BlockStatementId),
     Synchronous((SynchronousStatementId, BlockStatementId)),
+}
 impl Scope {
     pub fn is_block(&self) -> bool {
         match &self {
             Scope::Definition(_) => false,
             Scope::Regular(_) => true,
             Scope::Synchronous(_) => true,
+        }
+    }
     pub fn to_block(&self) -> BlockStatementId {
         match &self {
             Scope::Regular(id) => *id,
             Scope::Synchronous((_, id)) => *id,
             _ => panic!("unable to get BlockStatement from Scope")
+        }
+    }
+}
 pub trait VariableScope {
     fn parent_scope(&self, h: &Heap) -> Option<Scope>;
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId>;
+}
 impl VariableScope for Scope {
     fn parent_scope(&self, h: &Heap) -> Option<Scope> {
         match self {
             Scope::Definition(def) => h[*def].parent_scope(h),
             Scope::Regular(stmt) => h[*stmt].parent_scope(h),
             Scope::Synchronous((stmt, _)) => h[*stmt].parent_scope(h),
+        }
+    }
     fn get_variable(&self, h: &Heap, id: &Identifier) -> Option<VariableId> {
         match self {
             Scope::Definition(def) => h[*def].get_variable(h, id),
             Scope::Regular(stmt) => h[*stmt].get_variable(h, id),
             Scope::Synchronous((stmt, _)) => h[*stmt].get_variable(h, id),
+        }
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Variable {
     Parameter(Parameter),
     Local(Local),
+}
 impl Variable {
     pub fn identifier(&self) -> &Identifier {
         match self {
             Variable::Parameter(var) => &var.identifier,
             Variable::Local(var) => &var.identifier,
+        }
+    }
     pub fn is_parameter(&self) -> bool {
         match self {
             Variable::Parameter(_) => true,
             _ => false,
+        }
+    }
     pub fn as_parameter(&self) -> &Parameter {
         match self {
             Variable::Parameter(result) => result,
             _ => panic!("Unable to cast `Variable` to `Parameter`"),
+        }
+    }
     pub fn as_local(&self) -> &Local {
         match self {
             Variable::Local(result) => result,
             _ => panic!("Unable to cast `Variable` to `Local`"),
+        }
+    }
     pub fn as_local_mut(&mut self) -> &mut Local {
         match self {
             Variable::Local(result) => result,
             _ => panic!("Unable to cast 'Variable' to 'Local'"),
+        }
+    }
+}
 impl SyntaxElement for Variable {
     fn position(&self) -> InputPosition {
         match self {
             Variable::Parameter(decl) => decl.position(),
             Variable::Local(decl) => decl.position(),
+        }
+    }
+}
 /// TODO: Remove distinction between parameter/local and add an enum to indicate
 ///     the distinction between the two
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Parameter {
     pub this: ParameterId,
     // Phase 1: parser
     pub position: InputPosition,
     pub parser_type: ParserTypeId,
     pub identifier: Identifier,
+}
 impl SyntaxElement for Parameter {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct Local {
     pub this: LocalId,
     // Phase 1: parser
     pub position: InputPosition,
     pub parser_type: ParserTypeId,
     pub identifier: Identifier,
     // Phase 2: linker
     pub relative_pos_in_block: u32,
+}
 impl SyntaxElement for Local {
     fn position(&self) -> InputPosition {
         self.position
+    }
+}
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub enum Definition {
     Struct(StructDefinition),
     Enum(EnumDefinition),
     Component(Component),
     Function(Function),
+}
 impl Definition {
     pub fn is_struct(&self) -> bool {
         match self {
             Definition::Struct(_) => true,
             _ => false
+        }
+    }
     pub fn as_struct(&self) -> &StructDefinition {
         match self {
             Definition::Struct(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'StructDefinition'"),
+        }
+    }
     pub fn is_enum(&self) -> bool {
         match self {
             Definition::Enum(_) => true,
             _ => false,
+        }
+    }
     pub fn as_enum(&self) -> &EnumDefinition {
         match self {
             Definition::Enum(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'EnumDefinition'"),
+        }
+    }
     pub fn is_component(&self) -> bool {
         match self {
             Definition::Component(_) => true,
             _ => false,
+        }
+    }
     pub fn as_component(&self) -> &Component {
         match self {
             Definition::Component(result) => result,
             _ => panic!("Unable to cast `Definition` to `Component`"),
+        }
+    }
     pub fn is_function(&self) -> bool {
         match self {
             Definition::Function(_) => true,
             _ => false,
+        }
+    }
     pub fn as_function(&self) -> &Function {
         match self {
             Definition::Function(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub fn identifier(&self) -> &Identifier {
         match self {
             Definition::Struct(def) => &def.identifier,
             Definition::Enum(def) => &def.identifier,
             Definition::Component(com) => &com.identifier,
             Definition::Function(fun) => &fun.identifier,
+        }
+    }

src/protocol/parser/type_resolver.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use super::type_table::{ConcreteType, ConcreteTypeVariant};
 use crate::protocol::inputsource::*;
 use super::type_table::*;
 use super::symbol_table::*;
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
 };
 use std::collections::HashMap;
 enum ExprType {
     Regular, // expression statement or return statement
     Memory, // memory statement's expression
     Condition, // if/while conditional statement
     Assert, // assert statement
 pub(crate) enum InferredPart {
     // Unknown section of inferred type, yet to be inferred
     Unknown,
     // No subtypes
     Message,
     Bool,
     Byte,
     Short,
     Int,
     Long,
     String,
     // One subtype
     Array,
     Slice,
     Input,
     Output,
     // One or more subtypes
     Instance(DefinitionId, usize),
+}
 impl From<ConcreteTypeVariant> for InferredPart {
     fn from(v: ConcreteTypeVariant) -> Self {
         use ConcreteTypeVariant as CTV;
         use InferredPart as IP;
         match v {
             CTV::Message => IP::Message,
             CTV::Bool => IP::Bool,
             CTV::Byte => IP::Byte,
             CTV::Short => IP::Short,
             CTV::Int => IP::Int,
             CTV::Long => IP::Long,
             CTV::String => IP::String,
             CTV::Array => IP::Array,
             CTV::Slice => IP::Slice,
             CTV::Input => IP::Input,
             CTV::Output => IP::Output,
             CTV::Instance(definition_id, num_sub) => IP::Instance(definition_id, num_sub),
+        }
+    }
+}
 pub(crate) struct InferenceType {
     origin: ParserTypeId,
     inferred: Vec<InferredPart>,
+}
 impl InferenceType {
     fn new(inferred_type: ParserTypeId) -> Self {
         Self{ origin: inferred_type, inferred: vec![InferredPart::Unknown] }
+    }
     fn assign_concrete(&mut self, concrete_type: &ConcreteType) {
         self.inferred.clear();
         self.inferred.reserve(concrete_type.v.len());
         for variant in concrete_type.v {
             self.inferred.push(InferredPart::from(variant))
+        }
+    }
+}
 // TODO: @cleanup I will do a very dirty implementation first, because I have no idea
 //  what I am doing.
 // Very rough idea:
 //  - go through entire AST first, find all places where we have inferred types
 //      (which may be embedded) and store them in some kind of map.
 //  - go through entire AST and visit all expressions depth-first. We will
 //      attempt to resolve the return type of each expression. If we can't then
 //      we store them in another lookup map and link the dependency on an
 //      inferred variable to that expression.
 //  - keep iterating until we have completely resolved all variables.
 /// This particular visitor will recurse depth-first into the AST and ensures
 /// that all expressions have the appropriate types. At the moment this implies:
 ///
 ///     - Type checking arguments to unary and binary operators.
 ///     - Type checking assignment, indexing, slicing and select expressions.
 ///     - Checking arguments to functions and component instantiations.
 ///
 /// This will be achieved by slowly descending into the AST. At any given
 /// expression we may depend on
 pub(crate) struct TypeResolvingVisitor {
     // Tracking traversal state
     expr_type: ExprType,
     // Buffers for iteration over substatements and subexpressions
     stmt_buffer: Vec<StatementId>,
     expr_buffer: Vec<ExpressionId>,
     // Map for associating "auto"/"polyarg" variables with a concrete type where
     // it is not yet determined.
     env: HashMap<ParserTypeId, ConcreteTypeVariant>
     // If instantiating a monomorph of a polymorphic proctype, then we store the
     // values of the polymorphic values here.
     polyvars: Vec<(Identifier, ConcreteTypeVariant)>,
     // 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_types: HashMap<ParserTypeId, InferenceType>,
     // Mapping from variable ID to parser type, optionally inferred, so then
     var_types: HashMap<VariableId, ParserTypeId>,
+}
 impl TypeResolvingVisitor {
     pub(crate) fn new() -> Self {
         TypeResolvingVisitor{
             expr_type: ExprType::Regular,
             stmt_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expr_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             env: HashMap::new(),
             infer_types: HashMap::new(),
             var_types: HashMap::new(),
+        }
+    }
     fn reset(&mut self) {
         self.expr_type = ExprType::Regular;
         self.stmt_buffer.clear();
         self.expr_buffer.clear();
         self.infer_types.clear();
         self.var_types.clear();
+    }
+}
 impl Visitor2 for TypeResolvingVisitor {
     // Definitions
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentId) -> VisitorResult {
         self.reset();
         let comp_def = &ctx.heap[id];
         for param_id in comp_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             self.var_types.insert(param_id.upcast(), param.parser_type);
+        }
         let body_stmt_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_stmt_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionId) -> VisitorResult {
         self.reset();
         let func_def = &ctx.heap[id];
         for param_id in func_def.parameters.clone() {
             let param = &ctx.heap[param_id];
             self.var_types.insert(param_id.upcast(), param.parser_type);
+        }
         let body_stmt_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_stmt_id)
+    }
     // Statements
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         // Transfer statements for traversal
         let block = &ctx.heap[id];
         let old_len_stmts = self.stmt_buffer.len();
         self.stmt_buffer.extend(&block.statements);
         let new_len_stmts = self.stmt_buffer.len();
         // Traverse statements
         for stmt_idx in old_len_stmts..new_len_stmts {
             let stmt_id = self.stmt_buffer[stmt_idx];
             self.expr_type = ExprType::Regular;
             self.visit_stmt(ctx, stmt_id)?;
         for stmt_id in block.statements.clone() {
             self.visit_stmt(ctx, stmt_id);
+        }
         self.stmt_buffer.truncate(old_len_stmts);
         Ok(())
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         let memory_stmt = &ctx.heap[id];
         let local = &ctx.heap[memory_stmt.variable];
         self.var_types.insert(memory_stmt.variable, )
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         Ok(())
+    }
+}
 impl TypeResolvingVisitor {
     /// Checks if the `ParserType` contains any inferred variables. If so then
     /// they will be inserted into the `infer_types` variable. Here we assume
     /// we're parsing the body of a proctype, so any reference to polymorphic
     /// variables must refer to the polymorphic arguments of the proctype's
     /// definition.
     /// TODO: @cleanup: The symbol_table -> type_table pattern appears quite
     ///     a lot, will likely need to create some kind of function for this
     fn insert_parser_type_if_needs_inference(
         &mut self, ctx: &mut Ctx, root_id: RootId, parser_type_id: ParserTypeId
     ) -> Result<(), ParseError2> {
         use ParserTypeVariant as PTV;
         let mut to_consider = vec![parser_type_id];
         while !to_consider.is_empty() {
             let parser_type_id = to_consider.pop().unwrap();
             let parser_type = &mut ctx.heap[parser_type_id];
             match &mut parser_type.variant {
                 PTV::Inferred => {
                     self.env.insert(parser_type_id, InferenceType::new(parser_type_id));
                 },
                 PTV::Array(subtype_id) => { to_consider.push(*subtype_id); },
                 PTV::Input(subtype_id) => { to_consider.push(*subtype_id); },
                 PTV::Output(subtype_id) => { to_consider.push(*subtype_id); },
                 PTV::Symbolic(symbolic) => {
                     // If not yet resolved, try to resolve
                     if symbolic.variant.is_none() {
                         let mut found = false;
                         for (poly_idx, (poly_var, _)) in self.polyvars.iter().enumerate() {
                             if symbolic.identifier.value == poly_var.value {
                                 // Found a match
                                 symbolic.variant = Some(SymbolicParserTypeVariant::PolyArg(poly_idx))
                                 found = true;
                                 break;
+                            }
+                        }
                         if !found {
                             // Attempt to find in symbol/type table
                             let symbol = ctx.symbols.resolve_namespaced_symbol(root_id, &symbolic.identifier);
                             if symbol.is_none() {
                                 let module_source = &ctx.module.source;
                                 return Err(ParseError2::new_error(
                                     module_source, symbolic.identifier.position,
                                     "Could not resolve symbol to a type"
                                 ));
+                            }
                             // Check if symbol was fully resolved
                             let (symbol, ident_iter) = symbol.unwrap();
                             if ident_iter.num_remaining() != 0 {
                                 let module_source = &ctx.module.source;
                                 ident_iter.
                                 return Err(ParseError2::new_error(
                                     module_source, symbolic.identifier.position,
                                     "Could not resolve symbol to a type"
                                 ).with_postfixed_info(
                                     module_source, symbol.position,
                                     "Could resolve part of the identifier to this symbol"
                                 ));
+                            }
                             // Check if symbol resolves to struct/enum
                             let definition_id = match symbol.symbol {
                                 Symbol::Namespace(_) => {
                                     let module_source = &ctx.module.source;
                                     return Err(ParseError2::new_error(
                                         module_source, symbolic.identifier.position,
                                         "Symbol resolved to a module instead of a type"
                                     ));
                                 },
                                 Symbol::Definition((_, definition_id)) => definition_id
                             };
                             // Retrieve from type table and make sure it is a
                             // reference to a struct/enum/union
                             // TODO: @types Allow function pointers
                             let def_type = ctx.types.get_base_definition(&definition_id);
                             debug_assert!(def_type.is_some(), "Expected to resolve definition ID to type definition in type table");
                             let def_type = def_type.unwrap();
                             let def_type_class = def_type.definition.type_class();
                             if !def_type_class.is_data_type() {
                                 return Err(ParseError2::new_error(
                                     &ctx.module.source, symbolic.identifier.position,
                                     &format!("Symbol refers to a {}, only data types are supported", def_type_class)
                                 ));
+                            }
                             // Now that we're certain it is a datatype, make
                             // sure that the number of polyargs in the symbolic
                             // type matches that of the definition, or conclude
                             // that all polyargs need to be inferred.
                             if symbolic.poly_args.len() != def_type.poly_args.len() {
                                 if symbolic.poly_args.is_empty() {
                                     // Modify ParserType to have auto-inferred
                                     // polymorphic arguments
                                     symbolic.poly_args.
+                                }
+                            }
+                        }
+                    }
                 },
                 _ => {} // Builtin, doesn't require inference
+            }
+        }
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/type_table.rs

➞

Show inline comments

 /**
 TypeTable
 Contains the type table: a datastructure that, when compilation succeeds,
 contains a concrete type definition for each AST type definition. In general
 terms the type table will go through the following phases during the compilation
 process:
 . The base type definitions are resolved after the parser phase has
         finished. This implies that the AST is fully constructed, but not yet
         annotated.
 . With the base type definitions resolved, the validation/linker phase will
         use the type table (together with the symbol table) to disambiguate
         terms (e.g. does an expression refer to a variable, an enum, a constant,
         etc.)
 . During the type checking/inference phase the type table is used to ensure
         that the AST contains valid use of types in expressions and statements.
         At the same time type inference will find concrete instantiations of
         polymorphic types, these will be stored in the type table as monomorphed
         instantiations of a generic type.
 . After type checking and inference (and possibly when constructing byte
         code) the type table will construct a type graph and solidify each
         non-polymorphic type and monomorphed instantiations of polymorphic types
         into concrete types.
 So a base type is defined by its (optionally polymorphic) representation in the
 AST. A concrete type has concrete types for each of the polymorphic arguments. A
 struct, enum or union may have polymorphic arguments but not actually be a
 polymorphic type. This happens when the polymorphic arguments are not used in
 the type definition itself. Similarly for functions/components: but here we just
 check the arguments/return type of the signature.
 Apart from base types and concrete types, we also use the term "embedded type"
 for types that are embedded within another type, such as a type of a struct
 struct field or of a union variant. Embedded types may themselves have
 polymorphic arguments and therefore form an embedded type tree.
 NOTE: for now a polymorphic definition of a function/component is illegal if the
     polymorphic arguments are not used in the arguments/return type. It should
     be legal, but we disallow it for now.
 TODO: Allow potentially cyclic datatypes and reject truly cyclic datatypes.
 TODO: Allow for the full potential of polymorphism
 TODO: Detect "true" polymorphism: for datatypes like structs/enum/unions this
     is simple. For functions we need to check the entire body. Do it here? Or
     do it somewhere else?
 TODO: Do we want to check fn argument collision here, or in validation phase?
 TODO: Make type table an on-demand thing instead of constructing all base types.
 TODO: Cleanup everything, feels like a lot can be written cleaner and with less
     assumptions on each function call.
 // TODO: Review all comments
 */
 use std::fmt::{Formatter, Result as FmtResult};
 use std::collections::{HashMap, VecDeque};
 use crate::protocol::ast::*;
 use crate::protocol::parser::symbol_table::{SymbolTable, Symbol};
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::*;
 //------------------------------------------------------------------------------
 // Defined Types
 //------------------------------------------------------------------------------
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum TypeClass {
     Enum,
     Union,
     Struct,
     Function,
     Component
+}
 impl TypeClass {
     pub(crate) fn display_name(&self) -> &'static str {
         match self {
             TypeClass::Enum => "enum",
             TypeClass::Union => "enum",
             TypeClass::Struct => "struct",
             TypeClass::Function => "function",
             TypeClass::Component => "component",
+        }
+    }
     pub(crate) fn is_data_type(&self) -> bool {
         self == TypeClass::Enum || self == TypeClass::Union || self == TypeClass::Struct
+    }
     pub(crate) fn is_proc_type(&self) -> bool {
         self == TypeClass::Function || self == TypeClass::Component
+    }
+}
 impl std::fmt::Display for TypeClass {
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
         write!(f, "{}", self.display_name())
+    }
+}
 /// Struct wrapping around a potentially polymorphic type. If the type does not
 /// have any polymorphic arguments then it will not have any monomorphs and
 /// `is_polymorph` will be set to `false`. A type with polymorphic arguments
 /// only has `is_polymorph` set to `true` if the polymorphic arguments actually
 /// appear in the types associated types (function return argument, struct
 /// field, enum variant, etc.). Otherwise the polymorphic argument is just a
 /// marker and does not influence the bytesize of the type.
 pub struct DefinedType {
     pub(crate) ast_definition: DefinitionId,
     pub(crate) definition: DefinedTypeVariant,
     pub(crate) poly_args: Vec<PolyArg>,
     pub(crate) is_polymorph: bool,
     pub(crate) is_pointerlike: bool,
     pub(crate) monomorphs: Vec<u32>, // TODO: ?
+}
 pub enum DefinedTypeVariant {
     Enum(EnumType),
     Union(UnionType),
     Struct(StructType),
     Function(FunctionType),
     Component(ComponentType)
+}
 pub struct PolyArg {
     identifier: Identifier,
     /// Whether the polymorphic argument is used directly in the definition of
     /// the type (not including bodies of function/component types)
     is_in_use: bool,
+}
 impl DefinedTypeVariant {
     pub(crate) fn type_class(&self) -> TypeClass {
         match self {
             DefinedTypeVariant::Enum(_) => TypeClass::Enum,
             DefinedTypeVariant::Union(_) => TypeClass::Union,
             DefinedTypeVariant::Struct(_) => TypeClass::Struct,
             DefinedTypeVariant::Function(_) => TypeClass::Function,
             DefinedTypeVariant::Component(_) => TypeClass::Component
+        }
+    }
+}
 /// `EnumType` is the classical C/C++ enum type. It has various variants with
 /// an assigned integer value. The integer values may be user-defined,
 /// compiler-defined, or a mix of the two. If a user assigns the same enum
 /// value multiple times, we assume the user is an expert and we consider both
 /// variants to be equal to one another.
 pub struct EnumType {
     variants: Vec<EnumVariant>,
     representation: PrimitiveType,
+}
 // TODO: Also support maximum u64 value
 pub struct EnumVariant {
     identifier: Identifier,
     value: i64,
+}
 /// `UnionType` is the algebraic datatype (or sum type, or discriminated union).
 /// A value is an element of the union, identified by its tag, and may contain
 /// a single subtype.
 pub struct UnionType {
     variants: Vec<UnionVariant>,
     tag_representation: PrimitiveType
+}
 pub struct UnionVariant {
     identifier: Identifier,
     parser_type: Option<ParserTypeId>,
     tag_value: i64,
+}
 pub struct StructType {
     fields: Vec<StructField>,
+}
 pub struct StructField {
     identifier: Identifier,
     parser_type: ParserTypeId,
+}
 pub struct FunctionType {
     return_type: ParserTypeId,
     arguments: Vec<FunctionArgument>
+}
 pub struct ComponentType {
     variant: ComponentVariant,
     arguments: Vec<FunctionArgument>
+}
 pub struct FunctionArgument {
     identifier: Identifier,
     parser_type: ParserTypeId,
+}
 //------------------------------------------------------------------------------
 // Type table
 //------------------------------------------------------------------------------
 // TODO: @cleanup Do I really need this, doesn't make the code that much cleaner
 struct TypeIterator {
     breadcrumbs: Vec<(RootId, DefinitionId)>
+}
 impl TypeIterator {
     fn new() -> Self {
         Self{ breadcrumbs: Vec::with_capacity(32) }
+    }
     fn reset(&mut self, root_id: RootId, definition_id: DefinitionId) {
         self.breadcrumbs.clear();
         self.breadcrumbs.push((root_id, definition_id))
+    }
     fn push(&mut self, root_id: RootId, definition_id: DefinitionId) {
         self.breadcrumbs.push((root_id, definition_id));
+    }
     fn contains(&self, root_id: RootId, definition_id: DefinitionId) -> bool {
         for (stored_root_id, stored_definition_id) in self.breadcrumbs.iter() {
             if *stored_root_id == root_id && *stored_definition_id == definition_id { return true; }
+        }
         return false
+    }
     fn top(&self) -> Option<(RootId, DefinitionId)> {
         self.breadcrumbs.last().map(|(r, d)| (*r, *d))
+    }
     fn pop(&mut self) {
         debug_assert!(!self.breadcrumbs.is_empty());
         self.breadcrumbs.pop();
+    }
+}
 #[derive(Copy, Clone)]
 pub(crate) enum ConcreteTypeVariant {
     // No subtypes
     Message,
     Bool,
     Byte,
     Short,
     Int,
     Long,
     String,
     // One subtype
     Array,
     Slice,
     Input,
     Output,
     // Multiple subtypes (definition of thing and number of poly args)
     Instance(DefinitionId, usize)
+}
 pub(crate) struct ConcreteType {
     // serialized version (interpret as serialized depth-first tree, with
     // variant indicating the number of children (subtypes))
     pub(crate) v: Vec<ConcreteTypeVariant>
+}
 /// Result from attempting to resolve a `ParserType` using the symbol table and
 /// the type table.
 enum ResolveResult {
     /// ParserType is a builtin type
     BuiltIn,
     /// ParserType points to a polymorphic argument, contains the index of the
     /// polymorphic argument in the outermost definition (e.g. we may have
     /// structs nested three levels deep, but in the innermost struct we can
     /// only use the polyargs that are specified in the type definition of the
     /// outermost struct).
     PolyArg(usize),
     /// ParserType points to a user-defined type that is already resolved in the
     /// type table.
     Resolved((RootId, DefinitionId)),
     /// ParserType points to a user-defined type that is not yet resolved into
     /// the type table.
     Unresolved((RootId, DefinitionId))
+}
 pub(crate) struct TypeTable {
     /// Lookup from AST DefinitionId to a defined type. Considering possible
     /// polymorphs is done inside the `DefinedType` struct.
     lookup: HashMap<DefinitionId, DefinedType>,
     /// Iterator over `(module, definition)` tuples used as workspace to make sure
     /// that each base definition of all a type's subtypes are resolved.
     iter: TypeIterator,
     /// Iterator over `parser type`s during the process where `parser types` are
     /// resolved into a `(module, definition)` tuple.
     parser_type_iter: VecDeque<ParserTypeId>,
+}
 pub(crate) struct TypeCtx<'a> {
     symbols: &'a SymbolTable,
     heap: &'a mut Heap,
     modules: &'a [LexedModule]
+}
 impl<'a> TypeCtx<'a> {
     pub(crate) fn new(symbols: &'a SymbolTable, heap: &'a mut Heap, modules: &'a [LexedModule]) -> Self {
         Self{ symbols, heap, modules }
+    }
+}
 impl TypeTable {
     /// Construct a new type table without any resolved types. Types will be
     /// resolved on-demand.
     pub(crate) fn new(ctx: &mut TypeCtx) -> Result<Self, ParseError2> {
         // Make sure we're allowed to cast root_id to index into ctx.modules
         if cfg!(debug_assertions) {
             for (index, module) in ctx.modules.iter().enumerate() {
                 debug_assert_eq!(index, module.root_id.index as usize);
+            }
+        }
         // Use context to guess hashmap size
         let reserve_size = ctx.heap.definitions.len();
         let mut table = Self{
             lookup: HashMap::with_capacity(reserve_size),
             iter: TypeIterator::new(),
             parser_type_iter: VecDeque::with_capacity(64),
         };
         // TODO: @cleanup Rework this hack
         for root_idx in 0..ctx.modules.len() {
             let last_definition_idx = ctx.heap[ctx.modules[root_idx].root_id].definitions.len();
             for definition_idx in 0..last_definition_idx {
                 let definition_id = ctx.heap[ctx.modules[root_idx].root_id].definitions[definition_idx];
                 table.resolve_base_definition(ctx, definition_id)?;
+            }
+        }
         debug_assert_eq!(table.lookup.len(), reserve_size, "mismatch in reserved size of type table");

src/protocol/parser/visitor.rs

➞

Show inline comments

 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::{symbol_table::*, type_table::*, LexedModule};
 type Unit = ();
 pub(crate) type VisitorResult = Result<Unit, ParseError2>;
 /// Globally configured vector capacity for statement buffers in visitor
 /// implementations
 pub(crate) const STMT_BUFFER_INIT_CAPACITY: usize = 256;
 /// Globally configured vector capacity for expression buffers in visitor
 /// implementations
 pub(crate) const EXPR_BUFFER_INIT_CAPACITY: usize = 256;
 /// Globally configured vector capacity for parser type buffers in visitor
 /// implementations
 pub(crate) const TYPE_BUFFER_INIT_CAPACITY: usize = 128;
 /// General context structure that is used while traversing the AST.
 pub(crate) struct Ctx<'p> {
     pub heap: &'p mut Heap,
     pub module: &'p LexedModule,
     pub symbols: &'p mut SymbolTable,
     pub types: &'p mut TypeTable,
+}
 /// Visitor is a generic trait that will fully walk the AST. The default
 /// implementation of the visitors is to not recurse. The exception is the
 /// top-level `visit_definition`, `visit_stmt` and `visit_expr` methods, which
 /// call the appropriate visitor function.
 pub(crate) trait Visitor2 {
     // Entry point
     fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {
         let mut def_index = 0;
         loop {
             let definition_id = {
                 let root = &ctx.heap[ctx.module.root_id];
                 if def_index >= root.definitions.len() {
                     return Ok(())
+                }
                 root.definitions[def_index]
             };
             self.visit_definition(ctx, definition_id)?;
             def_index += 1;
+        }
+    }
     // Definitions
     // --- enum matching
     fn visit_definition(&mut self, ctx: &mut Ctx, id: DefinitionId) -> VisitorResult {
         match &ctx.heap[id] {
             Definition::Enum(def) => {
                 let def = def.this;
                 self.visit_enum_definition(ctx, def)
             },
             Definition::Struct(def) => {
                 let def = def.this;
                 self.visit_struct_definition(ctx, def)
             },
             Definition::Component(def) => {
                 let def = def.this;
                 self.visit_component_definition(ctx, def)
             },
             Definition::Function(def) => {
                 let def = def.this;
                 self.visit_function_definition(ctx, def)
+            }
+        }
+    }
     // --- enum variant handling
     fn visit_enum_definition(&mut self, _ctx: &mut Ctx, _id: EnumId) -> VisitorResult { Ok(()) }
     fn visit_struct_definition(&mut self, _ctx: &mut Ctx, _id: StructId) -> VisitorResult { Ok(()) }
     fn visit_component_definition(&mut self, _ctx: &mut Ctx, _id: ComponentId) -> VisitorResult { Ok(()) }
     fn visit_function_definition(&mut self, _ctx: &mut Ctx, _id: FunctionId) -> VisitorResult { Ok(()) }
     // Statements
     // --- enum matching
     fn visit_stmt(&mut self, ctx: &mut Ctx, id: StatementId) -> VisitorResult {
         match &ctx.heap[id] {
             Statement::Block(stmt) => {
                 let this = stmt.this;
                 self.visit_block_stmt(ctx, this)
             },
             Statement::Local(stmt) => {
                 let this = stmt.this();
                 self.visit_local_stmt(ctx, this)
             },
             Statement::Skip(stmt) => {
                 let this = stmt.this;
                 self.visit_skip_stmt(ctx, this)
             },
             Statement::Labeled(stmt) => {
                 let this = stmt.this;
                 self.visit_labeled_stmt(ctx, this)
             },
             Statement::If(stmt) => {
                 let this = stmt.this;
                 self.visit_if_stmt(ctx, this)
             },
             Statement::EndIf(_stmt) => Ok(()),
             Statement::While(stmt) => {
                 let this = stmt.this;
                 self.visit_while_stmt(ctx, this)
             },
             Statement::EndWhile(_stmt) => Ok(()),
             Statement::Break(stmt) => {
                 let this = stmt.this;
                 self.visit_break_stmt(ctx, this)
             },
             Statement::Continue(stmt) => {
@@ @@ -142,97 +145,100 @@ pub(crate) trait Visitor2 { @@
+        }
+    }
     fn visit_local_stmt(&mut self, ctx: &mut Ctx, id: LocalStatementId) -> VisitorResult {
         match &ctx.heap[id] {
             LocalStatement::Channel(stmt) => {
                 let this = stmt.this;
                 self.visit_local_channel_stmt(ctx, this)
             },
             LocalStatement::Memory(stmt) => {
                 let this = stmt.this;
                 self.visit_local_memory_stmt(ctx, this)
             },
+        }
+    }
     // --- enum variant handling
     fn visit_block_stmt(&mut self, _ctx: &mut Ctx, _id: BlockStatementId) -> VisitorResult { Ok(()) }
     fn visit_local_memory_stmt(&mut self, _ctx: &mut Ctx, _id: MemoryStatementId) -> VisitorResult { Ok(()) }
     fn visit_local_channel_stmt(&mut self, _ctx: &mut Ctx, _id: ChannelStatementId) -> VisitorResult { Ok(()) }
     fn visit_skip_stmt(&mut self, _ctx: &mut Ctx, _id: SkipStatementId) -> VisitorResult { Ok(()) }
     fn visit_labeled_stmt(&mut self, _ctx: &mut Ctx, _id: LabeledStatementId) -> VisitorResult { Ok(()) }
     fn visit_if_stmt(&mut self, _ctx: &mut Ctx, _id: IfStatementId) -> VisitorResult { Ok(()) }
     fn visit_while_stmt(&mut self, _ctx: &mut Ctx, _id: WhileStatementId) -> VisitorResult { Ok(()) }
     fn visit_break_stmt(&mut self, _ctx: &mut Ctx, _id: BreakStatementId) -> VisitorResult { Ok(()) }
     fn visit_continue_stmt(&mut self, _ctx: &mut Ctx, _id: ContinueStatementId) -> VisitorResult { Ok(()) }
     fn visit_synchronous_stmt(&mut self, _ctx: &mut Ctx, _id: SynchronousStatementId) -> VisitorResult { Ok(()) }
     fn visit_return_stmt(&mut self, _ctx: &mut Ctx, _id: ReturnStatementId) -> VisitorResult { Ok(()) }
     fn visit_assert_stmt(&mut self, _ctx: &mut Ctx, _id: AssertStatementId) -> VisitorResult { Ok(()) }
     fn visit_goto_stmt(&mut self, _ctx: &mut Ctx, _id: GotoStatementId) -> VisitorResult { Ok(()) }
     fn visit_new_stmt(&mut self, _ctx: &mut Ctx, _id: NewStatementId) -> VisitorResult { Ok(()) }
     fn visit_put_stmt(&mut self, _ctx: &mut Ctx, _id: PutStatementId) -> VisitorResult { Ok(()) }
     fn visit_expr_stmt(&mut self, _ctx: &mut Ctx, _id: ExpressionStatementId) -> VisitorResult { Ok(()) }
     // Expressions
     // --- enum matching
     fn visit_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> VisitorResult {
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let this = expr.this;
                 self.visit_assignment_expr(ctx, this)
             },
             Expression::Conditional(expr) => {
                 let this = expr.this;
                 self.visit_conditional_expr(ctx, this)
+            }
             Expression::Binary(expr) => {
                 let this = expr.this;
                 self.visit_binary_expr(ctx, this)
+            }
             Expression::Unary(expr) => {
                 let this = expr.this;
                 self.visit_unary_expr(ctx, this)
+            }
             Expression::Indexing(expr) => {
                 let this = expr.this;
                 self.visit_indexing_expr(ctx, this)
+            }
             Expression::Slicing(expr) => {
                 let this = expr.this;
                 self.visit_slicing_expr(ctx, this)
+            }
             Expression::Select(expr) => {
                 let this = expr.this;
                 self.visit_select_expr(ctx, this)
+            }
             Expression::Array(expr) => {
                 let this = expr.this;
                 self.visit_array_expr(ctx, this)
+            }
             Expression::Constant(expr) => {
                 let this = expr.this;
                 self.visit_constant_expr(ctx, this)
+            }
             Expression::Call(expr) => {
                 let this = expr.this;
                 self.visit_call_expr(ctx, this)
+            }
             Expression::Variable(expr) => {
                 let this = expr.this;
                 self.visit_variable_expr(ctx, this)
+            }
+        }
+    }
     fn visit_assignment_expr(&mut self, _ctx: &mut Ctx, _id: AssignmentExpressionId) -> VisitorResult { Ok(()) }
     fn visit_conditional_expr(&mut self, _ctx: &mut Ctx, _id: ConditionalExpressionId) -> VisitorResult { Ok(()) }
     fn visit_binary_expr(&mut self, _ctx: &mut Ctx, _id: BinaryExpressionId) -> VisitorResult { Ok(()) }
     fn visit_unary_expr(&mut self, _ctx: &mut Ctx, _id: UnaryExpressionId) -> VisitorResult { Ok(()) }
     fn visit_indexing_expr(&mut self, _ctx: &mut Ctx, _id: IndexingExpressionId) -> VisitorResult { Ok(()) }
     fn visit_slicing_expr(&mut self, _ctx: &mut Ctx, _id: SlicingExpressionId) -> VisitorResult { Ok(()) }
     fn visit_select_expr(&mut self, _ctx: &mut Ctx, _id: SelectExpressionId) -> VisitorResult { Ok(()) }
     fn visit_array_expr(&mut self, _ctx: &mut Ctx, _id: ArrayExpressionId) -> VisitorResult { Ok(()) }
     fn visit_constant_expr(&mut self, _ctx: &mut Ctx, _id: ConstantExpressionId) -> VisitorResult { Ok(()) }
     fn visit_call_expr(&mut self, _ctx: &mut Ctx, _id: CallExpressionId) -> VisitorResult { Ok(()) }
     fn visit_variable_expr(&mut self, _ctx: &mut Ctx, _id: VariableExpressionId) -> VisitorResult { Ok(()) }
     // Types
     fn visit_parser_type(&mut self, _ctx: &mut Ctx, _id: ParserTypeId) -> VisitorResult { Ok(()) }
+}
@@ \ No newline at end of file @@

src/protocol/parser/visitor_linker.rs

➞

Show inline comments

 use std::mem::{replace, swap};
 use crate::protocol::ast::*;
 use crate::protocol::inputsource::*;
 use crate::protocol::parser::{symbol_table::*, type_table::*};
 use super::visitor::{
     STMT_BUFFER_INIT_CAPACITY,
     EXPR_BUFFER_INIT_CAPACITY,
     TYPE_BUFFER_INIT_CAPACITY,
     Ctx,
     Visitor2,
     VisitorResult
 };
 use crate::protocol::ast::ExpressionParent::ExpressionStmt;
 #[derive(PartialEq, Eq)]
 enum DefinitionType {
     Primitive,
     Composite,
     Function
     None,
     Primitive(ComponentId),
     Composite(ComponentId),
     Function(FunctionId)
+}
 impl DefinitionType {
     fn is_primitive(&self) -> bool { if let Self::Primitive(_) = self { true } else { false } }
     fn is_composite(&self) -> bool { if let Self::Composite(_) = self { true } else { false } }
     fn is_function(&self) -> bool { if let Self::Function(_) = self { true } else { false } }
+}
 /// This particular visitor will go through the entire AST in a recursive manner
 /// and check if all statements and expressions are legal (e.g. no "return"
 /// statements in component definitions), and will link certain AST nodes to
 /// their appropriate targets (e.g. goto statements, or function calls).
 ///
 /// This visitor will not perform control-flow analysis (e.g. making sure that
 /// each function actually returns) and will also not perform type checking. So
 /// the linking of function calls and component instantiations will be checked
 /// and linked to the appropriate definitions, but the return types and/or
 /// arguments will not be checked for validity.
 ///
 /// The visitor visits each statement in a block in a breadth-first manner
 /// first. We are thereby sure that we have found all variables/labels in a
 /// particular block. In this phase nodes may queue statements for insertion
 /// (e.g. the insertion of an `EndIf` statement for a particular `If`
 /// statement). These will be inserted after visiting every node, after which
 /// the visitor recurses into each statement in a block.
 ///
 /// Because of this scheme expressions will not be visited in the breadth-first
 /// pass.
 pub(crate) struct ValidityAndLinkerVisitor {
     /// `in_sync` is `Some(id)` if the visitor is visiting the children of a
     /// synchronous statement. A single value is sufficient as nested
     /// synchronous statements are not allowed
     in_sync: Option<SynchronousStatementId>,
     /// `in_while` contains the last encountered `While` statement. This is used
     /// to resolve unlabeled `Continue`/`Break` statements.
     in_while: Option<WhileStatementId>,
     // Traversal state: current scope (which can be used to find the parent
     // scope), the definition variant we are considering, and whether the
     // visitor is performing breadthwise block statement traversal.
     cur_scope: Option<Scope>,
     def_type: DefinitionType,
     performing_breadth_pass: bool,
     // Parent expression (the previous stmt/expression we visited that could be
     // used as an expression parent)
     expr_parent: ExpressionParent,
     // Keeping track of relative position in block in the breadth-first pass.
     // May not correspond to block.statement[index] if any statements are
     // inserted after the breadth-pass
     relative_pos_in_block: u32,
     // Single buffer of statement IDs that we want to traverse in a block.
     // Required to work around Rust borrowing rules and to prevent constant
     // cloning of vectors.
     statement_buffer: Vec<StatementId>,
     // Another buffer, now with expression IDs, to prevent constant cloning of
     // vectors while working around rust's borrowing rules
     expression_buffer: Vec<ExpressionId>,
     // Yet another buffer, now with parser type IDs, similar to above
     parser_type_buffer: Vec<ParserTypeId>,
     // Statements to insert after the breadth pass in a single block
     insert_buffer: Vec<(u32, StatementId)>,
+}
 impl ValidityAndLinkerVisitor {
     pub(crate) fn new() -> Self {
         Self{
             in_sync: None,
             in_while: None,
             cur_scope: None,
             expr_parent: ExpressionParent::None,
-            def_type: DefinitionType::Primitive,
+            def_type: DefinitionType::None,
             performing_breadth_pass: false,
             relative_pos_in_block: 0,
             statement_buffer: Vec::with_capacity(STMT_BUFFER_INIT_CAPACITY),
             expression_buffer: Vec::with_capacity(EXPR_BUFFER_INIT_CAPACITY),
             parser_type_buffer: Vec::with_capacity(TYPE_BUFFER_INIT_CAPACITY),
             insert_buffer: Vec::with_capacity(32),
+        }
+    }
     fn reset_state(&mut self) {
         self.in_sync = None;
         self.in_while = None;
         self.cur_scope = None;
         self.expr_parent = ExpressionParent::None;
-        self.def_type = DefinitionType::Primitive;
+        self.def_type = DefinitionType::None;
         self.relative_pos_in_block = 0;
         self.performing_breadth_pass = false;
         self.statement_buffer.clear();
         self.expression_buffer.clear();
         self.parser_type_buffer.clear();
         self.insert_buffer.clear();
+    }
+}
 impl Visitor2 for ValidityAndLinkerVisitor {
     //--------------------------------------------------------------------------
     // Definition visitors
     //--------------------------------------------------------------------------
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentId) -> VisitorResult {
         self.reset_state();
         self.def_type = match &ctx.heap[id].variant {
             ComponentVariant::Primitive => DefinitionType::Primitive,
             ComponentVariant::Composite => DefinitionType::Composite,
             ComponentVariant::Primitive => DefinitionType::Primitive(id),
             ComponentVariant::Composite => DefinitionType::Composite(id),
         };
         self.cur_scope = Some(Scope::Definition(id.upcast()));
         self.expr_parent = ExpressionParent::None;
         let body_id = ctx.heap[id].body;
         // Visit types of parameters
         debug_assert!(self.parser_type_buffer.is_empty());
         let comp_def = &ctx.heap[id];
         self.parser_type_buffer.extend(
             comp_def.parameters
                 .iter()
                 .map(|id| ctx.heap[*id].parser_type)
         );
         let num_types = self.parser_type_buffer.len();
         for idx in 0..num_types {
             self.visit_parser_type(ctx, self.parser_type_buffer[idx])?;
+        }
         self.parser_type_buffer.clear();
         // Visit statements in component body
         let body_id = ctx.heap[id].body;
         self.performing_breadth_pass = true;
         self.visit_stmt(ctx, body_id)?;
         self.performing_breadth_pass = false;
         self.visit_stmt(ctx, body_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionId) -> VisitorResult {
         self.reset_state();
         // Set internal statement indices
         self.def_type = DefinitionType::Function;
+        self.def_type = DefinitionType::Function(id);
         self.cur_scope = Some(Scope::Definition(id.upcast()));
         self.expr_parent = ExpressionParent::None;
         // Visit types of parameters
         debug_assert!(self.parser_type_buffer.is_empty());
         let func_def = &ctx.heap[id];
         self.parser_type_buffer.extend(
             func_def.parameters
                 .iter()
                 .map(|id| ctx.heap[*id].parser_type)
         );
         self.parser_type_buffer.push(func_def.return_type);
         let num_types = self.parser_type_buffer.len();
         for idx in 0..num_types {
             self.visit_parser_type(ctx, self.parser_type_buffer[idx])?;
+        }
         self.parser_type_buffer.clear();
         // Visit statements in function body
         let body_id = ctx.heap[id].body;
         self.performing_breadth_pass = true;
         self.visit_stmt(ctx, body_id)?;
         self.performing_breadth_pass = false;
         self.visit_stmt(ctx, body_id)
+    }
     //--------------------------------------------------------------------------
     // Statement visitors
     //--------------------------------------------------------------------------
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
         self.visit_block_stmt_with_hint(ctx, id, None)
+    }
     fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let variable_id = ctx.heap[id].variable;
             self.checked_local_add(ctx, self.relative_pos_in_block, variable_id)?;
         } else {
             let variable_id = ctx.heap[id].variable;
             let parser_type_id = ctx.heap[variable_id].parser_type;
             self.visit_parser_type(ctx, parser_type_id);
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::Memory(id);
             self.visit_expr(ctx, ctx.heap[id].initial)?;
             self.expr_parent = ExpressionParent::None;
+        }
         Ok(())
+    }
     fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let (from_id, to_id) = {
                 let stmt = &ctx.heap[id];
                 (stmt.from, stmt.to)
             };
             self.checked_local_add(ctx, self.relative_pos_in_block, from_id)?;
             self.checked_local_add(ctx, self.relative_pos_in_block, to_id)?;
         } else {
             let chan_stmt = &ctx.heap[id];
             let from_type_id = ctx.heap[chan_stmt.from].parser_type;
             let to_type_id = ctx.heap[chan_stmt.to].parser_type;
             self.visit_parser_type(ctx, from_type_id)?;
             self.visit_parser_type(ctx, to_type_id)?;
+        }
         Ok(())
+    }
     fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             // Add label to block lookup
             self.checked_label_add(ctx, id)?;
             // Modify labeled statement itself
             let labeled = &mut ctx.heap[id];
             labeled.relative_pos_in_block = self.relative_pos_in_block;
             labeled.in_sync = self.in_sync.clone();
+        }
         let body_id = ctx.heap[id].body;
         self.visit_stmt(ctx, body_id)?;
         Ok(())
+    }
     fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let position = ctx.heap[id].position;
             let end_if_id = ctx.heap.alloc_end_if_statement(|this| {
                 EndIfStatement {
                     this,
                     start_if: id,
                     position,
                     next: None,
+                }
             });
             let stmt = &mut ctx.heap[id];
             stmt.end_if = Some(end_if_id);
             self.insert_buffer.push((self.relative_pos_in_block + 1, end_if_id.upcast()));
         } else {
             // Traverse expression and bodies
             let (test_id, true_id, false_id) = {
                 let stmt = &ctx.heap[id];
                 (stmt.test, stmt.true_body, stmt.false_body)
             };
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::If(id);
             self.visit_expr(ctx, test_id)?;
             self.expr_parent = ExpressionParent::None;
             self.visit_stmt(ctx, true_id)?;
             self.visit_stmt(ctx, false_id)?;
+        }
         Ok(())
+    }
     fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let position = ctx.heap[id].position;
             let end_while_id = ctx.heap.alloc_end_while_statement(|this| {
                 EndWhileStatement {
                     this,
                     start_while: id,
                     position,
                     next: None,
+                }
             });
             let stmt = &mut ctx.heap[id];
             stmt.end_while = Some(end_while_id);
             stmt.in_sync = self.in_sync.clone();
             self.insert_buffer.push((self.relative_pos_in_block + 1, end_while_id.upcast()));
         } else {
             let (test_id, body_id) = {
                 let stmt = &ctx.heap[id];
                 (stmt.test, stmt.body)
             };
             let old_while = self.in_while.replace(id);
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::While(id);
             self.visit_expr(ctx, test_id)?;
             self.expr_parent = ExpressionParent::None;
             self.visit_stmt(ctx, body_id)?;
             self.in_while = old_while;
+        }
         Ok(())
+    }
     fn visit_break_stmt(&mut self, ctx: &mut Ctx, id: BreakStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             // Should be able to resolve break statements with a label in the
             // breadth pass, no need to do after resolving all labels
             let target_end_while = {
                 let stmt = &ctx.heap[id];
                 let target_while_id = self.resolve_break_or_continue_target(ctx, stmt.position, &stmt.label)?;
                 let target_while = &ctx.heap[target_while_id];
                 debug_assert!(target_while.end_while.is_some());
                 target_while.end_while.unwrap()
             };
             let stmt = &mut ctx.heap[id];
             stmt.target = Some(target_end_while);
+        }
         Ok(())
+    }
     fn visit_continue_stmt(&mut self, ctx: &mut Ctx, id: ContinueStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let target_while_id = {
                 let stmt = &ctx.heap[id];
                 self.resolve_break_or_continue_target(ctx, stmt.position, &stmt.label)?
             };
             let stmt = &mut ctx.heap[id];
             stmt.target = Some(target_while_id)
+        }
         Ok(())
+    }
     fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             // Check for validity of synchronous statement
             let cur_sync_position = ctx.heap[id].position;
             if self.in_sync.is_some() {
                 // Nested synchronous statement
                 let old_sync = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, cur_sync_position, "Illegal nested synchronous statement")
                         .with_postfixed_info(&ctx.module.source, old_sync.position, "It is nested in this synchronous statement")
                 );
+            }
-            if self.def_type != DefinitionType::Primitive {
+            if !self.def_type.is_primitive() {
                 return Err(ParseError2::new_error(
                     &ctx.module.source, cur_sync_position,
                     "Synchronous statements may only be used in primitive components"
                 ));
+            }
             // Append SynchronousEnd pseudo-statement
             let sync_end_id = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement{
                 this,
                 position: cur_sync_position,
                 start_sync: id,
                 next: None,
             });
             let sync_start = &mut ctx.heap[id];
             sync_start.end_sync = Some(sync_end_id);
             self.insert_buffer.push((self.relative_pos_in_block + 1, sync_end_id.upcast()));
         } else {
             let sync_body = ctx.heap[id].body;
             let old = self.in_sync.replace(id);
             self.visit_stmt_with_hint(ctx, sync_body, Some(id))?;
             self.in_sync = old;
+        }
         Ok(())
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         if self.performing_breadth_pass {
             let stmt = &ctx.heap[id];
-            if self.def_type != DefinitionType::Function {
+            if !self.def_type.is_function() {
                 return Err(
                     ParseError2::new_error(&ctx.module.source, stmt.position, "Return statements may only appear in function bodies")
                 );
+            }
         } else {
             // If here then we are within a function
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::Return(id);
             self.visit_expr(ctx, ctx.heap[id].expression)?;
             self.expr_parent = ExpressionParent::None;
+        }
         Ok(())
+    }
     fn visit_assert_stmt(&mut self, ctx: &mut Ctx, id: AssertStatementId) -> VisitorResult {
         let stmt = &ctx.heap[id];
         if self.performing_breadth_pass {
-            if self.def_type == DefinitionType::Function {
+            if self.def_type.is_function() {
                 // TODO: We probably want to allow this. Mark the function as
                 //  using asserts, and then only allow calls to these functions
                 //  within components. Such a marker will cascade through any
                 //  functions that then call an asserting function
                 return Err(
                     ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal assert statement in a function")
                 );
+            }
             // We are in a component of some sort, but we also need to be within a
             // synchronous statement
             if self.in_sync.is_none() {
                 return Err(
                     ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal assert statement outside of a synchronous block")
                 );
+            }
         } else {
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             let expr_id = stmt.expression;
             self.expr_parent = ExpressionParent::Assert(id);
             self.visit_expr(ctx, expr_id)?;
             self.expr_parent = ExpressionParent::None;
+        }
         Ok(())
+    }
     fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {
         if !self.performing_breadth_pass {
             // Must perform goto label resolving after the breadth pass, this
             // way we are able to find all the labels in current and outer
             // scopes.
             let target_id = self.find_label(ctx, &ctx.heap[id].label)?;
             ctx.heap[id].target = Some(target_id);
             let target = &ctx.heap[target_id];
             if self.in_sync != target.in_sync {
                 // We can only goto the current scope or outer scopes. Because
                 // nested sync statements are not allowed so if the value does
                 // not match, then we must be inside a sync scope
                 debug_assert!(self.in_sync.is_some());
                 let goto_stmt = &ctx.heap[id];
                 let sync_stmt = &ctx.heap[self.in_sync.unwrap()];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, goto_stmt.position, "Goto may not escape the surrounding synchronous block")
                         .with_postfixed_info(&ctx.module.source, target.position, "This is the target of the goto statement")
                         .with_postfixed_info(&ctx.module.source, sync_stmt.position, "Which will jump past this statement")
                 );
+            }
+        }
         Ok(())
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         // Link the call expression following the new statement
         if self.performing_breadth_pass {
             // TODO: Cleanup error messages, can be done cleaner
             // Make sure new statement occurs within a composite component
             let call_expr_id = ctx.heap[id].expression;
-            if self.def_type != DefinitionType::Composite {
+            if !self.def_type.is_composite() {
                 let new_stmt = &ctx.heap[id];
                 return Err(
                     ParseError2::new_error(&ctx.module.source, new_stmt.position, "Instantiating components may only be done in composite components")
                 );
+            }
             // No fancy recursive parsing, must be followed by a call expression
             let definition_id = {
                 let call_expr = &ctx.heap[call_expr_id];
                 if let Method::Symbolic(symbolic) = &call_expr.method {
                     let found_symbol = self.find_symbol_of_type(
                         ctx.module.root_id, &ctx.symbols, &ctx.types,
                         &symbolic.identifier, TypeClass::Component
                     );
                     match found_symbol {
                         FindOfTypeResult::Found(definition_id) => definition_id,
                         FindOfTypeResult::TypeMismatch(got_type_class) => {
                             return Err(ParseError2::new_error(
                                 &ctx.module.source, symbolic.identifier.position,
                                 &format!("New must instantiate a component, this identifier points to a {}", got_type_class)
                             ))
                         },
                         FindOfTypeResult::NotFound => {
                             return Err(ParseError2::new_error(
                                 &ctx.module.source, symbolic.identifier.position,
                                 "Could not find a defined component with this name"
                             ))
+                        }
+                    }
                 } else {
                     return Err(
                         ParseError2::new_error(&ctx.module.source, call_expr.position, "Must instantiate a component")
                     );
+                }
             };
             // Modify new statement's symbolic call to point to the appropriate
             // definition.
             let call_expr = &mut ctx.heap[call_expr_id];
             match &mut call_expr.method {
                 Method::Symbolic(method) => method.definition = Some(definition_id),
                 _ => unreachable!()
+            }
         } else {
             // Performing depth pass. The function definition should have been
             // resolved in the breadth pass, now we recurse to evaluate the
             // arguments
             // TODO: @cleanup Maybe just call `visit_call_expr`?
             let call_expr_id = ctx.heap[id].expression;
             let call_expr = &mut ctx.heap[call_expr_id];
             call_expr.parent = ExpressionParent::New(id);
             let old_num_exprs = self.expression_buffer.len();
             self.expression_buffer.extend(&call_expr.arguments);
             let new_num_exprs = self.expression_buffer.len();
             let old_expr_parent = self.expr_parent;
             for arg_expr_idx in old_num_exprs..new_num_exprs {
                 let arg_expr_id = self.expression_buffer[arg_expr_idx];
                 self.expr_parent = ExpressionParent::Expression(call_expr_id.upcast(), arg_expr_idx as u32);
                 self.visit_expr(ctx, arg_expr_id)?;
+            }
             self.expression_buffer.truncate(old_num_exprs);
             self.expr_parent = old_expr_parent;
+        }
         Ok(())
+    }
     fn visit_put_stmt(&mut self, ctx: &mut Ctx, id: PutStatementId) -> VisitorResult {
         // TODO: Make `put` an expression. Perhaps silly, but much easier to
         //  perform typechecking
         if self.performing_breadth_pass {
             let put_stmt = &ctx.heap[id];
             if self.in_sync.is_none() {
                 return Err(ParseError2::new_error(
                     &ctx.module.source, put_stmt.position, "Put must be called in a synchronous block"
                 ));
+            }
         } else {
             let put_stmt = &ctx.heap[id];
             let port = put_stmt.port;
             let message = put_stmt.message;
             debug_assert_eq!(self.expr_parent, ExpressionParent::None);
             self.expr_parent = ExpressionParent::Put(id, 0);
             self.visit_expr(ctx, port)?;
             self.expr_parent = ExpressionParent::Put(id, 1);
             self.visit_expr(ctx, message)?;
             self.expr_parent = ExpressionParent::None;
+        }
         Ok(())
@@ @@ -619,268 +676,326 @@ impl Visitor2 for ValidityAndLinkerVisitor { @@
         let old_expr_parent = self.expr_parent;
         indexing_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 1);
         self.visit_expr(ctx, index_expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let slicing_expr = &mut ctx.heap[id];
         let subject_expr_id = slicing_expr.subject;
         let from_expr_id = slicing_expr.from_index;
         let to_expr_id = slicing_expr.to_index;
         let old_expr_parent = self.expr_parent;
         slicing_expr.parent = old_expr_parent;
         self.expr_parent = ExpressionParent::Expression(upcast_id, 0);
         self.visit_expr(ctx, subject_expr_id)?;
         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.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         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;
         self.expr_parent = ExpressionParent::Expression(id.upcast(), 0);
         self.visit_expr(ctx, expr_id)?;
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let upcast_id = id.upcast();
         let array_expr = &mut ctx.heap[id];
         let old_num_exprs = self.expression_buffer.len();
         self.expression_buffer.extend(&array_expr.elements);
         let new_num_exprs = self.expression_buffer.len();
         let old_expr_parent = self.expr_parent;
         array_expr.parent = old_expr_parent;
         for field_expr_idx in old_num_exprs..new_num_exprs {
             let field_expr_id = self.expression_buffer[field_expr_idx];
             self.expr_parent = ExpressionParent::Expression(upcast_id, field_expr_idx as u32);
             self.visit_expr(ctx, field_expr_id)?;
+        }
         self.expression_buffer.truncate(old_num_exprs);
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_constant_expr(&mut self, ctx: &mut Ctx, id: ConstantExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let constant_expr = &mut ctx.heap[id];
         constant_expr.parent = self.expr_parent;
         Ok(())
+    }
     fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let call_expr = &mut ctx.heap[id];
         // Resolve the method to the appropriate definition and check the
         // legality of the particular method call.
         match &mut call_expr.method {
             Method::Create => {},
             Method::Fires => {
-                if self.def_type != DefinitionType::Primitive {
+                if !self.def_type.is_primitive() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'fires' may only occur in primitive component definitions"
                     ));
+                }
             },
             Method::Get => {
-                if self.def_type != DefinitionType::Primitive {
+                if !self.def_type.is_primitive() {
                     return Err(ParseError2::new_error(
                         &ctx.module.source, call_expr.position,
                         "A call to 'get' may only occur in primitive component definitions"
                     ));
+                }
             },
             Method::Symbolic(symbolic) => {
                 // Find symbolic method
                 let found_symbol = self.find_symbol_of_type(
                     ctx.module.root_id, &ctx.symbols, &ctx.types,
                     &symbolic.identifier, TypeClass::Function
                 );
                 let definition_id = match found_symbol {
                     FindOfTypeResult::Found(definition_id) => definition_id,
                     FindOfTypeResult::TypeMismatch(got_type_class) => {
                         return Err(ParseError2::new_error(
                             &ctx.module.source, symbolic.identifier.position,
                             &format!("Only functions can be called, this identifier points to a {}", got_type_class)
                         ))
                     },
                     FindOfTypeResult::NotFound => {
                         return Err(ParseError2::new_error(
                             &ctx.module.source, symbolic.identifier.position,
                             &format!("Could not find a function with this name")
                         ))
+                    }
                 };
                 symbolic.definition = Some(definition_id);
+            }
+        }
         // Parse all the arguments in the depth pass as well. Note that we check
         // the number of arguments in the type checker.
         let call_expr = &mut ctx.heap[id];
         let upcast_id = id.upcast();
         let old_num_exprs = self.expression_buffer.len();
         self.expression_buffer.extend(&call_expr.arguments);
         let new_num_exprs = self.expression_buffer.len();
         let old_expr_parent = self.expr_parent;
         call_expr.parent = old_expr_parent;
         for arg_expr_idx in old_num_exprs..new_num_exprs {
             let arg_expr_id = self.expression_buffer[arg_expr_idx];
             self.expr_parent = ExpressionParent::Expression(upcast_id, arg_expr_idx as u32);
             self.visit_expr(ctx, arg_expr_id)?;
+        }
         self.expression_buffer.truncate(old_num_exprs);
         self.expr_parent = old_expr_parent;
         Ok(())
+    }
     fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {
         debug_assert!(!self.performing_breadth_pass);
         let var_expr = &ctx.heap[id];
         let variable_id = self.find_variable(ctx, self.relative_pos_in_block, &var_expr.identifier)?;
         let var_expr = &mut ctx.heap[id];
         var_expr.declaration = Some(variable_id);
         var_expr.parent = self.expr_parent;
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // ParserType visitors
     //--------------------------------------------------------------------------
     fn visit_parser_type(&mut self, ctx: &mut Ctx, id: ParserTypeId) -> VisitorResult {
         // We visit a particular type rooted in a non-ParserType node in the
         // AST. Within this function we set up a buffer to visit all nested
         // ParserType nodes.
         // The goal is to link symbolic ParserType instances to the appropriate
         // definition or symbolic type. Alternatively to throw an error if we
         // cannot resolve the ParserType to either of these (polymorphic) types.
         use ParserTypeVariant as PTV;
         debug_assert!(!self.performing_breadth_pass);
         let init_num_types = self.parser_type_buffer.len();
         self.parser_type_buffer.push(id);
         'resolve_loop: while self.parser_type_buffer.len() > init_num_types {
             let parser_type_id = self.parser_type_buffer.pop().unwrap();
             let parser_type = &ctx.heap[parser_type_id];
             match &parser_type.variant {
                 PTV::Message | PTV::Bool |
                 PTV::Byte | PTV::Short | PTV::Int | PTV::Long |
                 PTV::String |
                 PTV::IntegerLiteral | PTV::Inferred => {
                     // Builtin types or types that do not require recursion
                     continue 'resolve_loop;
                 },
                 PTV::Array(subtype_id) |
                 PTV::Input(subtype_id) |
                 PTV::Output(subtype_id) => {
                     // Requires recursing
                     self.parser_type_buffer.push(*subtype_id);
                     continue 'resolve_loop;
                 },
                 PTV::Symbolic(symbolic) => {
                     // Retrieve poly_vars from function/component definition to
                     // match against.
                     let poly_vars = match self.def_type {
                         DefinitionType::None => unreachable!(),
                         DefinitionType::Primitive(id) => &ctx.heap[id].poly_vars,
                         DefinitionType::Composite(id) => &ctx.heap[id].poly_vars,
                         DefinitionType::Function(id) => &ctx.heap[id].poly_vars,
                     };
                     for (poly_var_idx, poly_var) in poly_vars.iter().enumerate() {
                         if symbolic.identifier.value == poly_var.value {
+                        }
+                    }
+                }
+            }
+        }
         Ok(())
+    }
+}
 enum FindOfTypeResult {
     // Identifier was exactly matched, type matched as well
     Found(DefinitionId),
     // Identifier was matched, but the type differs from the expected one
     TypeMismatch(&'static str),
     // Identifier could not be found
     NotFound,
+}
 impl ValidityAndLinkerVisitor {
     //--------------------------------------------------------------------------
     // Special traversal
     //--------------------------------------------------------------------------
     /// Will visit a statement with a hint about its wrapping statement. This is
     /// used to distinguish block statements with a wrapping synchronous
     /// statement from normal block statements.
     fn visit_stmt_with_hint(&mut self, ctx: &mut Ctx, id: StatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {
         if let Statement::Block(block_stmt) = &ctx.heap[id] {
             let block_id = block_stmt.this;
             self.visit_block_stmt_with_hint(ctx, block_id, hint)
         } else {
             self.visit_stmt(ctx, id)
+        }
+    }
     fn visit_block_stmt_with_hint(&mut self, ctx: &mut Ctx, id: BlockStatementId, hint: Option<SynchronousStatementId>) -> VisitorResult {
         if self.performing_breadth_pass {
             // Performing a breadth pass, so don't traverse into the statements
             // of the block.
             return Ok(())
+        }
         // Set parent scope and relative position in the parent scope. Remember
         // these values to set them back to the old values when we're done with
         // the traversal of the block's statements.
         let body = &mut ctx.heap[id];
         body.parent_scope = self.cur_scope.clone();
         body.relative_pos_in_parent = self.relative_pos_in_block;
         let old_scope = self.cur_scope.replace(match hint {
             Some(sync_id) => Scope::Synchronous((sync_id, id)),
             None => Scope::Regular(id),
         });
         let old_relative_pos = self.relative_pos_in_block;
         // Copy statement IDs into buffer
         let old_num_stmts = self.statement_buffer.len();
+        {
             let body = &ctx.heap[id];
             self.statement_buffer.extend_from_slice(&body.statements);
+        }
         let new_num_stmts = self.statement_buffer.len();
         // Perform the breadth-first pass. Its main purpose is to find labeled
         // statements such that we can find the `goto`-targets immediately when
         // performing the depth pass
         self.performing_breadth_pass = true;
         for stmt_idx in old_num_stmts..new_num_stmts {
             self.relative_pos_in_block = (stmt_idx - old_num_stmts) as u32;
             self.visit_stmt(ctx, self.statement_buffer[stmt_idx])?;
+        }
         if !self.insert_buffer.is_empty() {
             let body = &mut ctx.heap[id];
             for (insert_idx, (pos, stmt)) in self.insert_buffer.drain(..).enumerate() {
                 body.statements.insert(pos as usize + insert_idx, stmt);
+            }
+        }
         // And the depth pass. Because we're not actually visiting any inserted
         // nodes because we're using the statement buffer, we may safely use the
         // relative_pos_in_block counter.
         self.performing_breadth_pass = false;
         for stmt_idx in old_num_stmts..new_num_stmts {
             self.relative_pos_in_block = (stmt_idx - old_num_stmts) as u32;
             self.visit_stmt(ctx, self.statement_buffer[stmt_idx])?;
+        }
         self.cur_scope = old_scope;
         self.relative_pos_in_block = old_relative_pos;
         // Pop statement buffer
         debug_assert!(self.insert_buffer.is_empty(), "insert buffer not empty after depth pass");
         self.statement_buffer.truncate(old_num_stmts);
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Utilities
     //--------------------------------------------------------------------------
     /// Adds a local variable to the current scope. It will also annotate the

0 comments (0 inline, 0 general)