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

Changeset - c6a9e4f128f2

Parent rev.

Child rev.

[Not reviewed]

0 17 0

mh - 3 years ago 2022-02-23 17:22:13
contact@maxhenger.nl

Unified component/function data into procedure

17 files changed with 283 insertions and 649 deletions:

src/collections/raw_vec.rs

src/protocol/ast.rs

136

src/protocol/ast_printer.rs

src/protocol/eval/error.rs

src/protocol/eval/executor.rs

src/protocol/mod.rs

src/protocol/parser/mod.rs

src/protocol/parser/pass_definitions.rs

src/protocol/parser/pass_rewriting.rs

src/protocol/parser/pass_stack_size.rs

src/protocol/parser/pass_symbols.rs

src/protocol/parser/pass_typing.rs

121

src/protocol/parser/pass_validation_linking.rs

src/protocol/parser/type_table.rs

129

src/protocol/parser/visitor.rs

src/protocol/tests/utils.rs

src/runtime2/component/component_pdl.rs

0 comments (0 inline, 0 general)

src/collections/raw_vec.rs

➞

Show inline comments

@@ @@ -59,26 +59,12 @@ impl<T: Sized> RawVec<T> { @@
             let target = self.base.add(self.len);
             std::ptr::write(target, item);
             self.len += 1;
+        }
+    }
     /// Moves the elements in the range [from_idx, from_idx + num_to_move) to
     /// the range [to_idx, to_idx + num_to_move). Caller must make sure that all
     /// non-overlapping elements of the second range had their destructor called
     /// in case those elements were used.
     pub fn move_range(&mut self, from_idx: usize, to_idx: usize, num_to_move: usize) {
         debug_assert!(from_idx + num_to_move <= self.len);
         debug_assert!(to_idx + num_to_move <= self.len); // maybe not in future, for now this is fine
         unsafe {
             let source = self.base.add(from_idx);
             let target = self.base.add(to_idx);
             std::ptr::copy(source, target, num_to_move);
+        }
+    }
     pub fn len(&self) -> usize {
         return self.len;
+    }
     pub fn as_slice(&self) -> &[T] {
         return unsafe{

src/protocol/ast.rs

➞

Show inline comments

 define_aliased_ast_id!(VariableId, Id<Variable>, index(Variable, variables), alloc(alloc_variable));
 define_aliased_ast_id!(DefinitionId, Id<Definition>, index(Definition, definitions));
 define_new_ast_id!(StructDefinitionId, DefinitionId, index(StructDefinition, Definition::Struct, definitions), alloc(alloc_struct_definition));
 define_new_ast_id!(EnumDefinitionId, DefinitionId, index(EnumDefinition, Definition::Enum, definitions), alloc(alloc_enum_definition));
 define_new_ast_id!(UnionDefinitionId, DefinitionId, index(UnionDefinition, Definition::Union, definitions), alloc(alloc_union_definition));
 define_new_ast_id!(ComponentDefinitionId, DefinitionId, index(ComponentDefinition, Definition::Component, definitions), alloc(alloc_component_definition));
 define_new_ast_id!(FunctionDefinitionId, DefinitionId, index(FunctionDefinition, Definition::Function, definitions), alloc(alloc_function_definition));
 define_new_ast_id!(ProcedureDefinitionId, DefinitionId, index(ProcedureDefinition, Definition::Procedure, definitions), alloc(alloc_procedure_definition));
 define_aliased_ast_id!(StatementId, Id<Statement>, index(Statement, statements));
 define_new_ast_id!(BlockStatementId, StatementId, index(BlockStatement, Statement::Block, statements), alloc(alloc_block_statement));
 define_new_ast_id!(EndBlockStatementId, StatementId, index(EndBlockStatement, Statement::EndBlock, statements), alloc(alloc_end_block_statement));
 define_new_ast_id!(LocalStatementId, StatementId, index(LocalStatement, Statement::Local, statements));
 define_new_ast_id!(MemoryStatementId, LocalStatementId);
@@ @@ -211,20 +210,26 @@ impl Heap { @@
+    }
+}
 impl Index<MemoryStatementId> for Heap {
     type Output = MemoryStatement;
     fn index(&self, index: MemoryStatementId) -> &Self::Output {
         &self.statements[index.0.0].as_memory()
         match &self.statements[index.0.0] {
             Statement::Local(LocalStatement::Memory(v)) => v,
             _ => unreachable!(),
+        }
+    }
+}
 impl Index<ChannelStatementId> for Heap {
     type Output = ChannelStatement;
     fn index(&self, index: ChannelStatementId) -> &Self::Output {
         &self.statements[index.0.0].as_channel()
         match &self.statements[index.0.0] {
             Statement::Local(LocalStatement::Channel(v)) => v,
             _ => unreachable!(),
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct Root {
     pub this: RootId,
@@ @@ -512,14 +517,14 @@ pub enum ConcreteTypePart { @@
     Output,
     Pointer,
     // Tuple: variable number of nested types, will never be 1
     Tuple(u32),
     // User defined type with any number of nested types
     Instance(DefinitionId, u32),    // instance of data type
     Function(DefinitionId, u32),    // instance of function
     Component(DefinitionId, u32),   // instance of a connector
     Function(ProcedureDefinitionId, u32),    // instance of function
     Component(ProcedureDefinitionId, u32),   // instance of a connector
+}
 impl ConcreteTypePart {
     pub(crate) fn num_embedded(&self) -> u32 {
         use ConcreteTypePart::*;
@@ @@ -648,33 +653,41 @@ impl ConcreteType { @@
                         target.push(',');
                         idx = Self::render_type_part_at(parts, heap, idx, target);
+                    }
+                }
                 target.push(')');
             },
             CTP::Instance(definition_id, num_poly_args) |
             CTP::Instance(definition_id, num_poly_args) => {
                 idx = Self::render_definition_type_parts_at(parts, heap, definition_id, num_poly_args, idx, target);
+            }
             CTP::Function(definition_id, num_poly_args) |
             CTP::Component(definition_id, num_poly_args) => {
                 let definition = &heap[definition_id];
                 target.push_str(definition.identifier().value.as_str());
                 if num_poly_args != 0 {
                     target.push('<');
                     for poly_arg_idx in 0..num_poly_args {
                         if poly_arg_idx != 0 {
                             target.push(',');
+                        }
                         idx = Self::render_type_part_at(parts, heap, idx, target);
+                    }
                     target.push('>');
+                }
                 idx = Self::render_definition_type_parts_at(parts, heap, definition_id.upcast(), num_poly_args, idx, target);
+            }
+        }
         idx
+    }
     fn render_definition_type_parts_at(parts: &[ConcreteTypePart], heap: &Heap, definition_id: DefinitionId, num_poly_args: u32, mut idx: usize, target: &mut String) -> usize {
         let definition = &heap[definition_id];
         target.push_str(definition.identifier().value.as_str());
         if num_poly_args != 0 {
             target.push('<');
             for poly_arg_idx in 0..num_poly_args {
                 if poly_arg_idx != 0 {
                     target.push(',');
+                }
                 idx = Self::render_type_part_at(parts, heap, idx, target);
+            }
             target.push('>');
+        }
         return idx;
+    }
+}
 #[derive(Debug)]
 pub struct ConcreteTypeIter<'a> {
     parts: &'a [ConcreteTypePart],
     idx_embedded: u32,
@@ @@ -795,14 +808,13 @@ pub struct Variable { @@
 #[derive(Debug, Clone)]
 pub enum Definition {
     Struct(StructDefinition),
     Enum(EnumDefinition),
     Union(UnionDefinition),
     Component(ComponentDefinition),
     Function(FunctionDefinition),
     Procedure(ProcedureDefinition),
+}
 impl Definition {
     pub fn is_struct(&self) -> bool {
         match self {
             Definition::Struct(_) => true,
@@ @@ -848,86 +860,64 @@ impl Definition { @@
     pub(crate) fn as_union(&self) -> &UnionDefinition {
         match self {
             Definition::Union(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'UnionDefinition'"),
+        }
+    }
     pub(crate) fn as_union_mut(&mut self) -> &mut UnionDefinition {
         match self {
             Definition::Union(result) => result,
             _ => panic!("Unable to cast 'Definition' to 'UnionDefinition'"),
+        }
+    }
     pub fn is_component(&self) -> bool {
         match self {
             Definition::Component(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_component(&self) -> &ComponentDefinition {
         match self {
             Definition::Component(result) => result,
             _ => panic!("Unable to cast `Definition` to `Component`"),
+        }
+    }
     pub(crate) fn as_component_mut(&mut self) -> &mut ComponentDefinition {
         match self {
             Definition::Component(result) => result,
             _ => panic!("Unable to cast `Definition` to `Component`"),
+        }
+    }
     pub fn is_function(&self) -> bool {
     pub fn is_procedure(&self) -> bool {
         match self {
-            Definition::Function(_) => true,
+            Definition::Procedure(_) => true,
             _ => false,
+        }
+    }
     pub(crate) fn as_function(&self) -> &FunctionDefinition {
     pub(crate) fn as_procedure(&self) -> &ProcedureDefinition {
         match self {
-            Definition::Function(result) => result,
+            Definition::Procedure(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub(crate) fn as_function_mut(&mut self) -> &mut FunctionDefinition {
     pub(crate) fn as_procedure_mut(&mut self) -> &mut ProcedureDefinition {
         match self {
-            Definition::Function(result) => result,
+            Definition::Procedure(result) => result,
             _ => panic!("Unable to cast `Definition` to `Function`"),
+        }
+    }
     pub fn parameters(&self) -> &Vec<VariableId> {
         match self {
             Definition::Component(def) => &def.parameters,
             Definition::Function(def) => &def.parameters,
             _ => panic!("Called parameters() on {:?}", self)
+        }
+    }
     pub fn defined_in(&self) -> RootId {
         match self {
             Definition::Struct(def) => def.defined_in,
             Definition::Enum(def) => def.defined_in,
             Definition::Union(def) => def.defined_in,
             Definition::Component(def) => def.defined_in,
             Definition::Function(def) => def.defined_in,
             Definition::Procedure(def) => def.defined_in,
+        }
+    }
     pub fn identifier(&self) -> &Identifier {
         match self {
             Definition::Struct(def) => &def.identifier,
             Definition::Enum(def) => &def.identifier,
             Definition::Union(def) => &def.identifier,
             Definition::Component(def) => &def.identifier,
             Definition::Function(def) => &def.identifier,
             Definition::Procedure(def) => &def.identifier,
+        }
+    }
     pub fn poly_vars(&self) -> &Vec<Identifier> {
         match self {
             Definition::Struct(def) => &def.poly_vars,
             Definition::Enum(def) => &def.poly_vars,
             Definition::Union(def) => &def.poly_vars,
             Definition::Component(def) => &def.poly_vars,
             Definition::Function(def) => &def.poly_vars,
             Definition::Procedure(def) => &def.poly_vars,
+        }
+    }
+}
 #[derive(Debug, Clone)]
 pub struct StructFieldDefinition {
@@ @@ -1015,81 +1005,55 @@ impl UnionDefinition { @@
         identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{ this, defined_in, span, identifier, poly_vars, variants: Vec::new() }
+    }
+}
 #[derive(Debug, Clone, Copy)]
 pub enum ComponentVariant {
     Primitive,
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ProcedureKind {
     Function, // with return type
     Primitive, // without return type
     Composite,
+}
 #[derive(Debug, Clone)]
 pub struct ComponentDefinition {
     pub this: ComponentDefinitionId,
     pub defined_in: RootId,
     // Symbol scanning
     pub span: InputSpan,
     pub variant: ComponentVariant,
     pub identifier: Identifier,
     pub poly_vars: Vec<Identifier>,
     // Parsing
     pub parameters: Vec<VariableId>,
     pub scope: ScopeId,
     pub body: BlockStatementId,
     // Validation/linking
     pub num_expressions_in_body: i32,
+}
 impl ComponentDefinition {
     // Used for preallocation during symbol scanning
     pub(crate) fn new_empty(
         this: ComponentDefinitionId, defined_in: RootId, span: InputSpan,
         variant: ComponentVariant, identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self{
             this, defined_in, span, variant, identifier, poly_vars,
             parameters: Vec::new(),
             scope: ScopeId::new_invalid(),
             body: BlockStatementId::new_invalid(),
             num_expressions_in_body: -1,
+        }
+    }
+}
 /// 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 FunctionDefinition {
     pub this: FunctionDefinitionId,
 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: ParserType,
+    pub return_type: Option<ParserType>, // present on functions, not components
     pub parameters: Vec<VariableId>,
     pub scope: ScopeId,
     pub body: BlockStatementId,
     // Monomorphization of typed procedures
     // Validation/linking
     pub num_expressions_in_body: i32,
+}
-impl FunctionDefinition {
+impl ProcedureDefinition {
     pub(crate) fn new_empty(
         this: FunctionDefinitionId, defined_in: RootId, span: InputSpan,
         identifier: Identifier, poly_vars: Vec<Identifier>
         this: ProcedureDefinitionId, defined_in: RootId, span: InputSpan,
         kind: ProcedureKind, identifier: Identifier, poly_vars: Vec<Identifier>
     ) -> Self {
         Self {
             this, defined_in,
             builtin: false,
             span, identifier, poly_vars,
             return_type: ParserType{ elements: Vec::new(), full_span: InputSpan::new() },
             span,
             kind, identifier, poly_vars,
             return_type: None,
             parameters: Vec::new(),
             scope: ScopeId::new_invalid(),
             body: BlockStatementId::new_invalid(),
             num_expressions_in_body: -1,
+        }
+    }
@@ @@ -1117,31 +1081,12 @@ pub enum Statement { @@
     Goto(GotoStatement),
     New(NewStatement),
     Expression(ExpressionStatement),
+}
 impl Statement {
     pub fn as_block(&self) -> &BlockStatement {
         match self {
             Statement::Block(result) => result,
             _ => panic!("Unable to cast `Statement` to `BlockStatement`"),
+        }
+    }
     pub fn as_local(&self) -> &LocalStatement {
         match self {
             Statement::Local(result) => result,
             _ => panic!("Unable to cast `Statement` to `LocalStatement`"),
+        }
+    }
     pub fn as_memory(&self) -> &MemoryStatement {
         self.as_local().as_memory()
+    }
     pub fn as_channel(&self) -> &ChannelStatement {
         self.as_local().as_channel()
+    }
     pub fn as_new(&self) -> &NewStatement {
         match self {
             Statement::New(result) => result,
             _ => panic!("Unable to cast `Statement` to `NewStatement`"),
+        }
+    }
@@ @@ -1231,24 +1176,12 @@ impl LocalStatement { @@
     pub fn this(&self) -> LocalStatementId {
         match self {
             LocalStatement::Memory(stmt) => stmt.this.upcast(),
             LocalStatement::Channel(stmt) => stmt.this.upcast(),
+        }
+    }
     pub fn as_memory(&self) -> &MemoryStatement {
         match self {
             LocalStatement::Memory(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `MemoryStatement`"),
+        }
+    }
     pub fn as_channel(&self) -> &ChannelStatement {
         match self {
             LocalStatement::Channel(result) => result,
             _ => panic!("Unable to cast `LocalStatement` to `ChannelStatement`"),
+        }
+    }
     pub fn span(&self) -> InputSpan {
         match self {
             LocalStatement::Channel(v) => v.span,
             LocalStatement::Memory(v) => v.span,
+        }
+    }
@@ @@ -1788,13 +1721,13 @@ pub struct CallExpression { @@
     // 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 definition: DefinitionId,
+    pub procedure: ProcedureDefinitionId,
     // Validator/Linker
     pub parent: ExpressionParent,
     pub unique_id_in_definition: i32,
+}
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ @@ -1809,13 +1742,13 @@ pub enum Method { @@
     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
-    UserFunction,
+    UserProcedure,
     UserComponent,
+}
 #[derive(Debug, Clone)]
 pub struct MethodSymbolic {
     pub(crate) parser_type: ParserType,

src/protocol/ast_printer.rs

➞

Show inline comments

@@ @@ -342,52 +342,35 @@ impl ASTWriter { @@
                             self.kv(indent4+1).with_s_key("Value")
                                 .with_custom_val(|v| write_parser_type(v, heap, embedded));
+                        }
+                    }
+                }
+            }
-            Definition::Function(def) => {
+            Definition::Procedure(def) => {
                 self.kv(indent).with_id(PREFIX_FUNCTION_ID, def.this.0.index)
                     .with_s_key("DefinitionFunction");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("ReturnParserType")
                     .with_custom_val(|s| write_parser_type(s, heap, &def.return_type));
                 self.kv(indent2).with_s_key("Kind").with_debug_val(&def.kind);
                 if let Some(parser_type) = &def.return_type {
                     self.kv(indent2).with_s_key("ReturnParserType")
                         .with_custom_val(|s| write_parser_type(s, heap, parser_type));
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for variable_id in &def.parameters {
                     self.write_variable(heap, *variable_id, indent3);
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body.upcast(), indent3);
             },
             Definition::Component(def) => {
                 self.kv(indent).with_id(PREFIX_COMPONENT_ID,def.this.0.index)
                     .with_s_key("DefinitionComponent");
                 self.kv(indent2).with_s_key("Name").with_identifier_val(&def.identifier);
                 self.kv(indent2).with_s_key("Variant").with_debug_val(&def.variant);
                 self.kv(indent2).with_s_key("PolymorphicVariables");
                 for poly_var_id in &def.poly_vars {
                     self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);
+                }
                 self.kv(indent2).with_s_key("Parameters");
                 for variable_id in &def.parameters {
                     self.write_variable(heap, *variable_id, indent3)
+                }
                 self.kv(indent2).with_s_key("Body");
                 self.write_stmt(heap, def.body.upcast(), indent3);
+            }
+        }
+    }
     fn write_stmt(&mut self, heap: &Heap, stmt_id: StatementId, indent: usize) {
         let stmt = &heap[stmt_id];
         let indent2 = indent + 1;
@@ @@ -779,25 +762,17 @@ impl ASTWriter { @@
+            }
             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);
                 let definition = &heap[expr.definition];
                 match definition {
                     Definition::Component(definition) => {
                         self.kv(indent2).with_s_key("BuiltIn").with_disp_val(&false);
                         self.kv(indent2).with_s_key("Variant").with_debug_val(&definition.variant);
                     },
                     Definition::Function(definition) => {
                         self.kv(indent2).with_s_key("BuiltIn").with_disp_val(&definition.builtin);
                         self.kv(indent2).with_s_key("Variant").with_s_val("Function");
                     },
                     _ => unreachable!()
+                }
                 self.kv(indent2).with_s_key("MethodName").with_identifier_val(definition.identifier());
                 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 {

src/protocol/eval/error.rs

➞

Show inline comments

@@ @@ -49,36 +49,26 @@ impl EvalError { @@
         let mut last_module_source = &modules[0].source;
         for frame in prompt.frames.iter() {
             let definition = &heap[frame.definition];
             let statement = &heap[frame.position];
             let statement_span = statement.span();
             let (root_id, procedure, is_func) = match definition {
                 Definition::Function(def) => {
                     (def.defined_in, def.identifier.value.as_str().to_string(), true)
                 },
                 Definition::Component(def) => {
                     (def.defined_in, def.identifier.value.as_str().to_string(), false)
                 },
                 _ => unreachable!("construct stack frame with definition pointing to data type")
             };
             // Lookup module name, if it has one
-            let module = modules.iter().find(|m| m.root_id == root_id).unwrap();
+            let module = modules.iter().find(|m| m.root_id == definition.defined_in).unwrap();
             let module_name = if let Some(name) = &module.name {
                 name.as_str().to_string()
             } else {
                 String::new()
             };
             last_module_source = &module.source;
             frames.push(EvalFrame{
                 line: statement_span.begin.line,
                 module_name,
                 procedure,
                 is_func
                 procedure: definition.identifier.value.as_str().to_string(),
                 is_func: definition.kind == ProcedureKind::Function,
             });
+        }
         let expr = &heap[expr_id];
         let statements = vec![
             ErrorStatement::from_source_at_span(StatementKind::Error, last_module_source, expr.full_span(), msg)

src/protocol/eval/executor.rs

➞

Show inline comments

@@ @@ -23,29 +23,26 @@ pub(crate) enum ExprInstruction { @@
     EvalExpr(ExpressionId),
     PushValToFront,
+}
 #[derive(Debug, Clone)]
 pub(crate) struct Frame {
-    pub(crate) definition: DefinitionId,
+    pub(crate) definition: ProcedureDefinitionId,
     pub(crate) monomorph_type_id: TypeId,
     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: DefinitionId, monomorph_type_id: TypeId) -> Self {
+    pub fn new(heap: &Heap, definition_id: ProcedureDefinitionId, monomorph_type_id: TypeId) -> Self {
         let definition = &heap[definition_id];
         let (outer_scope_id, first_statement_id) = match definition {
             Definition::Component(definition) => (definition.scope, definition.body),
             Definition::Function(definition) => (definition.scope, definition.body),
             _ => unreachable!("initializing frame with {:?} instead of a function/component", definition),
         };
         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];
@@ @@ -208,26 +205,26 @@ pub enum EvalContinuation { @@
     BlockFires(PortId),
     BlockGet(PortId),
     Put(PortId, ValueGroup),
     // Returned only in non-sync mode
     ComponentTerminated,
     SyncBlockStart,
-    NewComponent(DefinitionId, TypeId, ValueGroup),
+    NewComponent(ProcedureDefinitionId, TypeId, ValueGroup),
     NewChannel,
+}
 // Note: cloning is fine, methinks. cloning all values and the heap regions then
 // we end up with valid "pointers" to heap regions.
 #[derive(Debug, Clone)]
 pub struct Prompt {
     pub(crate) frames: Vec<Frame>,
     pub(crate) store: Store,
+}
 impl Prompt {
-    pub fn new(_types: &TypeTable, heap: &Heap, def: DefinitionId, type_id: TypeId, args: ValueGroup) -> Self {
+    pub fn new(_types: &TypeTable, heap: &Heap, def: ProcedureDefinitionId, type_id: TypeId, args: ValueGroup) -> Self {
         let mut prompt = Self{
             frames: Vec::new(),
             store: Store::new(),
         };
         // Maybe do typechecking in the future?
@@ @@ -288,13 +285,13 @@ impl Prompt { @@
+            )
+        }
         // Checking if we're at the end of execution
         let cur_frame = self.frames.last_mut().unwrap();
         if cur_frame.position.is_invalid() {
-            if heap[cur_frame.definition].is_function() {
+            if heap[cur_frame.definition].kind == ProcedureKind::Function {
                 todo!("End of function without return, return an evaluation error");
+            }
             return Ok(EvalContinuation::ComponentTerminated);
+        }
         debug_log!("Taking step in '{}'", heap[cur_frame.definition].identifier().value.as_str());
@@ @@ -742,16 +739,16 @@ impl Prompt { @@
                                 Method::SelectWait => {
                                     todo!("select wait");
                                 },
                                 Method::UserComponent => {
                                     // This is actually handled by the evaluation
                                     // of the statement.
-                                    debug_assert_eq!(heap[expr.definition].parameters().len(), cur_frame.expr_values.len());
+                                    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::UserFunction => {
+                                Method::UserProcedure => {
                                     // 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
@@ @@ -767,22 +764,22 @@ impl Prompt { @@
                                     // 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];
                                     // Push the new frame and reserve its stack size
-                                    let new_frame = Frame::new(heap, expr.definition, call_data.type_id);
+                                    let new_frame = Frame::new(heap, expr.procedure, call_data.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)
@@ @@ -974,13 +971,12 @@ impl Prompt { @@
                     self.store.clear_stack(scope.first_unique_id_in_scope as usize);
+                }
                 Ok(EvalContinuation::Stepping)
             },
             Statement::Return(_stmt) => {
                 debug_assert!(heap[cur_frame.definition].is_function());
                 debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for return statement");
                 // The preceding frame has executed a call, so is expecting the
                 // return expression on its expression value stack. Note that
                 // we may be returning a reference to something on our stack,
                 // so we need to read that value and clone it.
@@ @@ -1021,15 +1017,14 @@ impl Prompt { @@
                 cur_frame.position = stmt.target.upcast();
                 Ok(EvalContinuation::Stepping)
             },
             Statement::New(stmt) => {
                 let call_expr = &heap[stmt.expression];
                 debug_assert!(heap[call_expr.definition].is_component());
                 debug_assert_eq!(
-                    cur_frame.expr_values.len(), heap[call_expr.definition].parameters().len(),
+                    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];
@@ @@ -1049,13 +1044,13 @@ impl Prompt { @@
                 for arg in &args {
                     self.store.drop_value(arg.get_heap_pos());
+                }
                 cur_frame.position = stmt.next;
-                Ok(EvalContinuation::NewComponent(call_expr.definition, expr_data.type_id, argument_group))
+                Ok(EvalContinuation::NewComponent(call_expr.procedure, expr_data.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;

src/protocol/mod.rs

➞

Show inline comments

@@ @@ -91,26 +91,26 @@ impl ProtocolDescription { @@
         if definition_id.is_none() {
             return Err(ComponentCreationError::DefinitionDoesntExist);
+        }
         let definition_id = definition_id.unwrap();
         let ast_definition = &self.heap[definition_id];
-        if !ast_definition.is_component() {
+        if !ast_definition.is_procedure() {
             return Err(ComponentCreationError::DefinitionNotComponent);
+        }
         // Make sure that the types of the provided value group matches that of
         // the expected types.
         let ast_definition = ast_definition.as_component();
         if !ast_definition.poly_vars.is_empty() {
         let ast_definition = ast_definition.as_procedure();
         if !ast_definition.poly_vars.is_empty() || ast_definition.kind == ProcedureKind::Function {
             return Err(ComponentCreationError::DefinitionNotComponent);
+        }
         // - check number of arguments by retrieving the one instantiated
         //   monomorph
-        let concrete_type = ConcreteType{ parts: vec![ConcreteTypePart::Component(definition_id, 0)] };
+        let concrete_type = ConcreteType{ parts: vec![ConcreteTypePart::Component(ast_definition.this, 0)] };
         let mono_index = self.types.get_procedure_monomorph_type_id(&definition_id, &concrete_type.parts).unwrap();
         let mono_type = self.types.get_procedure_monomorph(mono_index);
         if mono_type.arg_types.len() != arguments.values.len() {
             return Err(ComponentCreationError::InvalidNumArguments);
+        }
@@ @@ -122,13 +122,13 @@ impl ProtocolDescription { @@
                 return Err(ComponentCreationError::InvalidArgumentType(arg_idx));
+            }
+        }
         // By now we're sure that all of the arguments are correct. So create
         // the connector.
-        return Ok(Prompt::new(&self.types, &self.heap, definition_id, mono_index, arguments));
+        return Ok(Prompt::new(&self.types, &self.heap, ast_definition.this, mono_index, arguments));
+    }
     fn lookup_module_root(&self, module_name: &[u8]) -> Option<RootId> {
         for module in self.modules.iter() {
             match &module.name {
                 Some(name) => if name.as_bytes() == module_name {

src/protocol/parser/mod.rs

➞

Show inline comments

@@ @@ -321,14 +321,14 @@ impl Parser { @@
                 modules: &mut self.modules,
                 module_idx,
                 symbols: &mut self.symbol_table,
                 types: &mut self.type_table,
                 arch: &self.arch,
             };
             self.pass_rewriting.visit_module(&mut ctx);
             self.pass_stack_size.visit_module(&mut ctx);
             self.pass_rewriting.visit_module(&mut ctx)?;
             self.pass_stack_size.visit_module(&mut ctx)?;
+        }
         // Write out desired information
         if let Some(filename) = &self.write_ast_to {
             let mut writer = ASTWriter::new();
             let mut file = std::fs::File::create(std::path::Path::new(filename)).unwrap();
     };
     return type_table.add_builtin_type(concrete_type, poly_var, size, alignment);
+}
 // Note: args and return type need to be a function because we need to know the function ID.
-fn insert_builtin_function<T: Fn(FunctionDefinitionId) -> (Vec<(&'static str, ParserType)>, ParserType)> (
+fn insert_builtin_function<T: Fn(ProcedureDefinitionId) -> (Vec<(&'static str, ParserType)>, ParserType)> (
     p: &mut Parser, func_name: &str, polymorphic: &[&str], arg_and_return_fn: T
 ) {
     let mut poly_vars = Vec::with_capacity(polymorphic.len());
     for poly_var in polymorphic {
         poly_vars.push(Identifier{ span: InputSpan::new(), value: p.string_pool.intern(poly_var.as_bytes()) });
+    }
     let func_ident_ref = p.string_pool.intern(func_name.as_bytes());
-    let func_id = p.heap.alloc_function_definition(|this| FunctionDefinition{
+    let procedure_id = p.heap.alloc_procedure_definition(|this| ProcedureDefinition {
         this,
         defined_in: RootId::new_invalid(),
         builtin: true,
         kind: ProcedureKind::Function,
         span: InputSpan::new(),
         identifier: Identifier{ span: InputSpan::new(), value: func_ident_ref.clone() },
         poly_vars,
-        return_type: ParserType{ elements: Vec::new(), full_span: InputSpan::new() },
+        return_type: None,
         parameters: Vec::new(),
         scope: ScopeId::new_invalid(),
         body: BlockStatementId::new_invalid(),
         num_expressions_in_body: -1,
     });
-    let (arguments, return_type) = arg_and_return_fn(func_id);
+    let (arguments, return_type) = arg_and_return_fn(procedure_id);
     let mut parameters = Vec::with_capacity(arguments.len());
     for (arg_name, arg_type) in arguments {
         let identifier = Identifier{ span: InputSpan::new(), value: p.string_pool.intern(arg_name.as_bytes()) };
         let param_id = p.heap.alloc_variable(|this| Variable{
             this,
             relative_pos_in_parent: 0,
             unique_id_in_scope: 0
         });
         parameters.push(param_id);
+    }
-    let func = &mut p.heap[func_id];
+    let func = &mut p.heap[procedure_id];
     func.parameters = parameters;
     func.return_type = return_type;
+    func.return_type = Some(return_type);
     p.symbol_table.insert_symbol(SymbolScope::Global, Symbol{
         name: func_ident_ref,
         variant: SymbolVariant::Definition(SymbolDefinition{
             defined_in_module: RootId::new_invalid(),
             defined_in_scope: SymbolScope::Global,
             definition_span: InputSpan::new(),
             identifier_span: InputSpan::new(),
             imported_at: None,
             class: DefinitionClass::Function,
-            definition_id: func_id.upcast(),
+            definition_id: procedure_id.upcast(),
         })
     }).unwrap();
+}
@@ \ No newline at end of file @@

src/protocol/parser/pass_definitions.rs

➞

Show inline comments

@@ @@ -281,14 +281,14 @@ impl PassDefinitions { @@
         // Consume block and the definition's scope
         let body_id = self.consume_block_statement(module, iter, ctx)?;
         let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Definition(definition_id)));
         // Assign everything in the preallocated AST node
         let function = ctx.heap[definition_id].as_function_mut();
         function.return_type = parser_type;
         let function = ctx.heap[definition_id].as_procedure_mut();
         function.return_type = Some(parser_type);
         function.parameters = parameters;
         function.scope = scope_id;
         function.body = body_id;
         Ok(())
+    }
@@ @@ -318,13 +318,14 @@ impl PassDefinitions { @@
         // Consume block
         let body_id = self.consume_block_statement(module, iter, ctx)?;
         let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Definition(definition_id)));
         // Assign everything in the AST node
         let component = ctx.heap[definition_id].as_component_mut();
         let component = ctx.heap[definition_id].as_procedure_mut();
         debug_assert!(component.return_type.is_none());
         component.parameters = parameters;
         component.scope = scope_id;
         component.body = body_id;
         Ok(())
+    }
@@ @@ -755,13 +756,13 @@ impl PassDefinitions { @@
         let mut valid = false;
         let mut call_id = CallExpressionId::new_invalid();
         if let Expression::Call(expression) = expression {
             // Allow both components and functions, as it makes more sense to
             // check their correct use in the validation and linking pass
-            if expression.method == Method::UserComponent || expression.method == Method::UserFunction {
+            if expression.method == Method::UserComponent || expression.method == Method::UserProcedure {
                 call_id = expression.this;
                 valid = true;
+            }
+        }
         if !valid {
@@ @@ -1573,57 +1574,42 @@ impl PassDefinitions { @@
                                         variant_idx: 0,
                                     }),
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
                             },
                             Definition::Component(_) => {
                                 // Component instantiation
                                 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: Method::UserComponent,
                                     arguments,
                                     definition: target_definition_id,
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
                             },
                             Definition::Function(function_definition) => {
                             Definition::Procedure(proc_def) => {
                                 // Check whether it is a builtin function
                                 let method = if function_definition.builtin {
                                     match function_definition.identifier.value.as_bytes() {
                                 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
                                 } else {
-                                    Method::UserFunction
+                                    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,
-                                    definition: target_definition_id,
+                                    procedure: procedure_id,
                                     parent: ExpressionParent::None,
                                     unique_id_in_definition: -1,
                                 }).upcast()
+                            }
+                        }
                     },

src/protocol/parser/pass_rewriting.rs

➞

Show inline comments

@@ @@ -42,23 +42,16 @@ impl Visitor for PassRewriting { @@
         ctx.module_mut().phase = ModuleCompilationPhase::Rewritten;
         return Ok(())
+    }
     // --- Visiting procedures
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         let def = &ctx.heap[id];
         let body_id = def.body;
         self.current_scope = def.scope;
         return self.visit_block_stmt(ctx, body_id);
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {
         let def = &ctx.heap[id];
         let body_id = def.body;
         self.current_scope = def.scope;
     fn visit_procedure_definition(&mut self, ctx: &mut Ctx, id: ProcedureDefinitionId) -> VisitorResult {
         let definition = &ctx.heap[id];
         let body_id = definition.body;
         self.current_scope = definition.scope;
         return self.visit_block_stmt(ctx, body_id);
+    }
     // --- Visiting statements (that are not the select statement)
     fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {
@@ @@ -159,13 +152,13 @@ impl Visitor for PassRewriting { @@
         // Create statements that will create temporary variables for all of the
         // ports passed to the "get" calls in the select case guards.
         let select_stmt = &ctx.heap[id];
         let total_num_cases = select_stmt.cases.len();
         let mut total_num_ports = 0;
         let end_select_stmt_id = select_stmt.end_select;
-        let end_select = &ctx.heap[end_select_stmt_id];
+        let _end_select = &ctx.heap[end_select_stmt_id];
         // Put heap IDs into temporary buffers to handle borrowing rules
         let mut call_id_section = self.call_expr_buffer.start_section();
         let mut expr_id_section = self.expression_buffer.start_section();
         for case in select_stmt.cases.iter() {
@@ @@ -310,13 +303,13 @@ impl PassRewriting { @@
             parser_type: ParserType{
                 elements: Vec::new(),
                 full_span: InputSpan::new(),
             },
             method,
             arguments,
-            definition: DefinitionId::new_invalid(),
+            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(),
         parser_type: ParserType{
             elements: Vec::new(),
             full_span: InputSpan::new(),
         },
         method,
         arguments,
-        definition: DefinitionId::new_invalid(),
+        procedure: ProcedureDefinitionId::new_invalid(),
         parent: ExpressionParent::None,
         unique_id_in_definition: -1,
     });
     for argument_index in 0..expression_ids.len() {
         let argument_id = expression_ids[argument_index];

src/protocol/parser/pass_stack_size.rs

➞

Show inline comments

@@ @@ -40,26 +40,18 @@ impl Visitor for PassStackSize { @@
         definition_section.forget();
         // ctx.module_mut().phase = ModuleCompilationPhase::StackSizeStuffAndStuff;
         return Ok(())
+    }
-    fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {
+    fn visit_procedure_definition(&mut self, ctx: &mut Ctx, id: ProcedureDefinitionId) -> VisitorResult {
         let definition = &ctx.heap[id];
         let scope_id = definition.scope;
         self.visit_scope_and_assign_local_ids(ctx, scope_id, 0);
         return Ok(())
+    }
     fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         let definition = &ctx.heap[id];
         let scope_id = definition.scope;
         self.visit_scope_and_assign_local_ids(ctx, scope_id, 0);
         return Ok(())
         return Ok(());
+    }
+}
 impl PassStackSize {
     fn visit_scope_and_assign_local_ids(&mut self, ctx: &mut Ctx, scope_id: ScopeId, mut variable_counter: i32) {
         let scope = &mut ctx.heap[scope_id];

src/protocol/parser/pass_symbols.rs

➞

Show inline comments

@@ @@ -227,29 +227,29 @@ impl PassSymbols { @@
                     UnionDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Union;
                 ast_definition_id = union_def_id.upcast()
             },
             KW_FUNCTION => {
                 let func_def_id = ctx.heap.alloc_function_definition(|this| {
                     FunctionDefinition::new_empty(this, module.root_id, definition_span, identifier, poly_vars)
                 let proc_def_id = ctx.heap.alloc_procedure_definition(|this| {
                     ProcedureDefinition::new_empty(this, module.root_id, definition_span, ProcedureKind::Function, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Function;
-                ast_definition_id = func_def_id.upcast();
+                ast_definition_id = proc_def_id.upcast();
             },
             KW_PRIMITIVE | KW_COMPOSITE => {
                 let component_variant = if kw_text == KW_PRIMITIVE {
                     ComponentVariant::Primitive
                 let procedure_kind = if kw_text == KW_PRIMITIVE {
                     ProcedureKind::Primitive
                 } else {
-                    ComponentVariant::Composite
+                    ProcedureKind::Composite
                 };
                 let comp_def_id = ctx.heap.alloc_component_definition(|this| {
                     ComponentDefinition::new_empty(this, module.root_id, definition_span, component_variant, identifier, poly_vars)
                 let proc_def_id = ctx.heap.alloc_procedure_definition(|this| {
                     ProcedureDefinition::new_empty(this, module.root_id, definition_span, procedure_kind, identifier, poly_vars)
                 });
                 definition_class = DefinitionClass::Component;
-                ast_definition_id = comp_def_id.upcast();
+                ast_definition_id = proc_def_id.upcast();
             },
             _ => unreachable!("encountered keyword '{}' in definition range", String::from_utf8_lossy(kw_text)),
+        }
         let symbol = Symbol{
             name: ident_text,

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -807,26 +807,12 @@ enum SingleInferenceResult { @@
 // -----------------------------------------------------------------------------
 type InferNodeIndex = usize;
 type PolyDataIndex = isize;
 type VarDataIndex = usize;
 enum DefinitionType{
     Component(ComponentDefinitionId),
     Function(FunctionDefinitionId),
+}
 impl DefinitionType {
     fn definition_id(&self) -> DefinitionId {
         match self {
             DefinitionType::Component(v) => v.upcast(),
             DefinitionType::Function(v) => v.upcast(),
+        }
+    }
+}
 pub(crate) struct ResolveQueueElement {
     // 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,
@@ @@ -1011,13 +997,14 @@ struct InferenceRuleVariableExpr { @@
 /// 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,
     definition_type: DefinitionType,
     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>,
@@ @@ -1089,13 +1076,14 @@ struct VarData { @@
+}
 impl PassTyping {
     pub(crate) fn new() -> Self {
         PassTyping {
             reserved_type_id: TypeId::new_invalid(),
             definition_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             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),
@@ @@ -1113,26 +1101,23 @@ impl PassTyping { @@
         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 {
-                Definition::Function(definition) => {
+                Definition::Procedure(definition) => {
                     if definition.poly_vars.is_empty() {
                         Some(ConcreteTypePart::Function(*definition_id, 0))
                         if definition.kind == ProcedureKind::Function {
                             Some(ConcreteTypePart::Function(definition.this, 0))
                         } else {
                             Some(ConcreteTypePart::Component(definition.this, 0))
+                        }
                     } else {
                         None
+                    }
+                }
                 Definition::Component(definition) => {
                     if definition.poly_vars.is_empty() {
                         Some(ConcreteTypePart::Component(*definition_id, 0))
                     } else {
                         None
+                    }
                 },
                 Definition::Enum(_) | Definition::Struct(_) | Definition::Union(_) => None,
             };
             if let Some(first_concrete_part) = first_concrete_part {
                 let concrete_type = ConcreteType{ parts: vec![first_concrete_part] };
                 let type_id = ctx.types.reserve_procedure_monomorph_type_id(definition_id, concrete_type);
@@ @@ -1169,13 +1154,14 @@ impl PassTyping { @@
         self.resolve_types(ctx, queue)?;
         Ok(())
+    }
     fn reset(&mut self) {
         self.reserved_type_id = TypeId::new_invalid();
         self.definition_type = DefinitionType::Function(FunctionDefinitionId::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();
@@ @@ -1198,66 +1184,25 @@ impl PassTyping { @@
+    }
     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_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
         self.definition_type = DefinitionType::Component(id);
         let comp_def = &ctx.heap[id];
         debug_assert_eq!(comp_def.poly_vars.len(), self.poly_vars.len(), "component polyvars do not match imposed polyvars");
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting component '{}': {}", comp_def.identifier.value.as_str(), id.0.index);
         debug_log!("{}", "-".repeat(50));
         // Visit parameters
         let section = self.var_buffer.start_section_initialized(comp_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 component 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 the body and all of its expressions
         let body_stmt_id = ctx.heap[id].body;
         self.parent_index = None;
         self.visit_block_stmt(ctx, body_stmt_id)
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {
         self.definition_type = DefinitionType::Function(id);
     fn visit_procedure_definition(&mut self, ctx: &mut Ctx, id: ProcedureDefinitionId) -> VisitorResult {
         let procedure_def = &ctx.heap[id];
         let func_def = &ctx.heap[id];
         debug_assert_eq!(func_def.poly_vars.len(), self.poly_vars.len(), "function polyvars do not match imposed polyvars");
         self.procedure_id = id;
         self.procedure_kind = procedure_def.kind;
         let body_id = procedure_def.body;
         debug_log!("{}", "-".repeat(50));
         debug_log!("Visiting function '{}': {}", func_def.identifier.value.as_str(), id.0.index);
         if debug_log_enabled!() {
             debug_log!("Polymorphic variables:");
             for (_idx, poly_var) in self.poly_vars.iter().enumerate() {
                 let mut infer_type_parts = Vec::new();
                 Self::determine_inference_type_from_concrete_type(
                     &mut infer_type_parts, &poly_var.parts
                 );
                 let _infer_type = InferenceType::new(false, true, infer_type_parts);
                 debug_log!(" - [{:03}] {:?}", _idx, _infer_type.display_name(&ctx.heap));
+            }
+        }
         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(func_def.parameters.as_slice());
+        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,
@@ @@ -1266,15 +1211,14 @@ impl PassTyping { @@
                 linked_var: None
             })
+        }
         section.forget();
         // Visit all of the expressions within the body
         let body_stmt_id = ctx.heap[id].body;
         self.parent_index = None;
-        self.visit_block_stmt(ctx, body_stmt_id)
+        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(()));
@@ @@ -2018,13 +1962,13 @@ impl PassTyping { @@
             // Go through all polymorphic arguments and add them to the concrete
             // types.
             for (poly_idx, poly_type) in inference.iter().enumerate() {
                 if !poly_type.is_done {
                     let expr = &ctx.heap[expr_id];
                     let definition = match expr {
-                        Expression::Call(expr) => expr.definition,
+                        Expression::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!()
                         },
@@ @@ -2069,22 +2013,22 @@ impl PassTyping { @@
             // 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::UserFunction {
                         ConcreteTypePart::Function(expr.definition, poly_data.poly_vars.len() as u32)
                     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.definition, poly_data.poly_vars.len() as u32)
+                        ConcreteTypePart::Component(expr.procedure, poly_data.poly_vars.len() as u32)
                     } else {
                         // Builtin function
                         continue;
                     };
-                    let definition_id = expr.definition;
+                    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) => {
@@ @@ -2125,22 +2069,13 @@ impl PassTyping { @@
+                }
+            }
+        }
         // Every expression checked, and new monomorphs are queued. Transfer the
         // expression information to the type table.
         let procedure_arguments = match &self.definition_type {
             DefinitionType::Component(id) => {
                 let definition = &ctx.heap[*id];
                 &definition.parameters
             },
             DefinitionType::Function(id) => {
                 let definition = &ctx.heap[*id];
                 &definition.parameters
             },
         };
         let procedure_arguments = &ctx.heap[self.procedure_id].parameters;
         let target = ctx.types.get_procedure_monomorph_mut(self.reserved_type_id);
         debug_assert!(target.arg_types.is_empty()); // makes sure we never queue a procedure's type inferencing twice
         debug_assert!(target.expr_data.is_empty());
         // - Write the arguments to the procedure
@@ @@ -3019,13 +2954,16 @@ impl PassTyping { @@
         let expr_type = &self.infer_nodes[node_index].expr_type;
         println!("DEBUG: Running test on {:?}", expr_type.parts);
         let mut part_index = 0;
         while part_index < expr_type.parts.len() {
             let part = &expr_type.parts[part_index];
             if part.is_marker() { continue; }
             if part.is_marker() {
                 part_index += 1;
                 continue;
+            }
             if !part.is_concrete() { break; }
             if *part == InferenceTypePart::String {
                 // First part is a string
                 return (true, false);
             } else {
@@ @@ -3215,13 +3153,13 @@ impl PassTyping { @@
     /// And so we have `outer_node_index` + `poly_data_type_index` pointing to
     /// the appropriate type in the `PolyData` struct. Which will be updated
     /// first using the polymorphic variables. If we happen to have updated that
     /// type, then we should also progress the associated expression, hence the
     /// `associated_node_index`.
     fn apply_polydata_polyvar_constraint(
-        &mut self, ctx: &Ctx,
+        &mut self, _ctx: &Ctx,
         outer_node_index: InferNodeIndex, poly_data_type_index: PolyDataTypeIndex,
         associated_node_index: InferNodeIndex, poly_progress_section: &ScopedSection<u32>
     ) -> bool {
         let poly_data_index = self.infer_nodes[outer_node_index].poly_data_index;
         let poly_data = &mut self.poly_data[poly_data_index as usize];
@@ @@ -3438,22 +3376,18 @@ impl PassTyping { @@
                     InferenceType::new(false, false, vec![ITP::Unknown])
+                }
             },
             EP::If(_) | EP::While(_) =>
                 // Must be a boolean
                 InferenceType::new(false, true, vec![ITP::Bool]),
             EP::Return(_) =>
+            EP::Return(_) => {
                 // Must match the return type of the function
                 if let DefinitionType::Function(func_id) = self.definition_type {
                     let returned = &ctx.heap[func_id].return_type;
                     self.determine_inference_type_from_parser_type_elements(&returned.elements, true)
                 } else {
                     // Cannot happen: definition always set upon body traversal
                     // and "return" calls in components are illegal.
                     unreachable!();
                 },
                 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]),
         };
@@ @@ -3490,47 +3424,39 @@ impl PassTyping { @@
         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.definition];
         let (parameters, returned) = match definition {
             Definition::Component(definition) => {
                 debug_assert_eq!(poly_args.len(), definition.poly_vars.len());
                 (&definition.parameters, None)
             },
             Definition::Function(definition) => {
                 debug_assert_eq!(poly_args.len(), definition.poly_vars.len());
                 (&definition.parameters, Some(&definition.return_type))
             },
             Definition::Struct(_) | Definition::Enum(_) | Definition::Union(_) => {
                 unreachable!("insert_initial_call_polymorph data for non-procedure type");
             },
         };
         let definition = &ctx.heap[call.procedure];
         debug_assert_eq!(poly_args.len(), definition.poly_vars.len());
         let mut parameter_types = Vec::with_capacity(parameters.len());
         for parameter_id in parameters.clone().into_iter() { // TODO: @Performance @Now
         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 returned {
+        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.definition,
+            definition_id: call.procedure.upcast(),
             poly_vars: poly_args,
             expr_types: PolyDataTypes {
                 associated: parameter_types,
                 returned: return_type
+            }
         });
@@ @@ -3822,13 +3748,13 @@ impl PassTyping { @@
                 PTV::Tuple(num_embedded) => { infer_type.push(ITP::Tuple(*num_embedded)); },
                 PTV::PolymorphicArgument(belongs_to_definition, poly_arg_idx) => {
                     let poly_arg_idx = *poly_arg_idx;
                     if use_definitions_known_poly_args {
                         // Refers to polymorphic argument on procedure we're currently processing.
                         // This argument is already known.
-                        debug_assert_eq!(*belongs_to_definition, self.definition_type.definition_id());
+                        debug_assert_eq!(*belongs_to_definition, self.procedure_id.upcast());
                         debug_assert!((poly_arg_idx as usize) < self.poly_vars.len());
                         Self::determine_inference_type_from_concrete_type(
                             &mut infer_type, &self.poly_vars[poly_arg_idx as usize].parts
                         );
                     } else {

src/protocol/parser/pass_validation_linking.rs

➞

Show inline comments

@@ @@ -47,32 +47,12 @@ use super::visitor::{ @@
     Ctx,
     Visitor,
     VisitorResult
 };
 use crate::protocol::parser::ModuleCompilationPhase;
 #[derive(PartialEq, Eq)]
 enum DefinitionType {
     Primitive(ComponentDefinitionId),
     Composite(ComponentDefinitionId),
     Function(FunctionDefinitionId)
+}
 impl DefinitionType {
     fn is_primitive(&self) -> bool { if let Self::Primitive(_) = self { true } else { false } }
     fn is_composite(&self) -> bool { if let Self::Composite(_) = self { true } else { false } }
     fn is_function(&self) -> bool { if let Self::Function(_) = self { true } else { false } }
     fn definition_id(&self) -> DefinitionId {
         match self {
             DefinitionType::Primitive(v) => v.upcast(),
             DefinitionType::Composite(v) => v.upcast(),
             DefinitionType::Function(v) => v.upcast(),
+        }
+    }
+}
 struct ControlFlowStatement {
     in_sync: SynchronousStatementId,
     in_while: WhileStatementId,
     in_scope: ScopeId,
     statement: StatementId, // of 'break', 'continue' or 'goto'
+}
@@ @@ -100,13 +80,14 @@ pub(crate) struct PassValidationLinking { @@
     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,
     def_type: DefinitionType,
     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
@@ @@ -136,13 +117,14 @@ impl PassValidationLinking { @@
             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,
             def_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),
             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),
@@ @@ -157,13 +139,14 @@ impl PassValidationLinking { @@
         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.def_type = DefinitionType::Function(FunctionDefinitionId::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();
@@ @@ -203,62 +186,23 @@ impl Visitor for PassValidationLinking { @@
         Ok(())
+    }
     //--------------------------------------------------------------------------
     // Definition visitors
     //--------------------------------------------------------------------------
-    fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {
+    fn visit_procedure_definition(&mut self, ctx: &mut Ctx, id: ProcedureDefinitionId) -> VisitorResult {
         self.reset_state();
         let definition = &ctx.heap[id];
         self.def_type = match &definition.variant {
             ComponentVariant::Primitive => DefinitionType::Primitive(id),
             ComponentVariant::Composite => DefinitionType::Composite(id),
         };
         self.expr_parent = ExpressionParent::None;
         // Visit parameters and assign a unique scope ID
         let definition_scope_id = definition.scope;
         let old_scope = self.push_scope(ctx, true, definition_scope_id);
         let definition = &ctx.heap[id];
         let body_id = definition.body;
         let section = self.variable_buffer.start_section_initialized(&definition.parameters);
         for variable_idx in 0..section.len() {
             let variable_id = section[variable_idx];
             self.checked_at_single_scope_add_local(ctx, self.cur_scope, -1, variable_id)?;
+        }
         self.relative_pos_in_parent = section.len() as i32;
         section.forget();
         // Visit statements in component body
         self.visit_block_stmt(ctx, body_id)?;
         self.pop_scope(old_scope);
         // Assign total number of expressions and assign an in-block unique ID
         // to each of the locals in the procedure.
         let definition = &mut ctx.heap[id];
         definition.num_expressions_in_body = self.next_expr_index;
         self.resolve_pending_control_flow_targets(ctx)?;
         Ok(())
+    }
     fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {
         self.reset_state();
         // Set internal statement indices
         self.def_type = DefinitionType::Function(id);
         self.proc_id = id;
         self.proc_kind = definition.kind;
         self.expr_parent = ExpressionParent::None;
         // Visit parameters and assign a unique scope ID
         let definition = &ctx.heap[id];
         let definition_scope_id = definition.scope;
         let old_scope = self.push_scope(ctx, true, definition_scope_id);
         // Visit parameters
         let scope_id = definition.scope;
         let old_scope = self.push_scope(ctx, true, scope_id);
         let definition = &ctx.heap[id];
         let body_id = definition.body;
         let section = self.variable_buffer.start_section_initialized(&definition.parameters);
         for variable_idx in 0..section.len() {
             let variable_id = section[variable_idx];
@@ @@ -457,13 +401,13 @@ impl Visitor for PassValidationLinking { @@
                 &ctx.module().source, cur_sync_span, "Illegal nested synchronous statement"
             ).with_info_str_at_span(
                 &ctx.module().source, old_sync_span, "It is nested in this synchronous statement"
             ));
+        }
-        if !self.def_type.is_primitive() {
+        if self.proc_kind != ProcedureKind::Primitive {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, cur_sync_span,
                 "synchronous statements may only be used in primitive components"
             ));
+        }
@@ @@ -529,13 +473,13 @@ impl Visitor for PassValidationLinking { @@
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, select_stmt.span,
                 "select statements may only occur inside sync blocks"
             ));
+        }
-        if !self.def_type.is_primitive() {
+        if self.proc_kind != ProcedureKind::Primitive {
             return Err(ParseError::new_error_str_at_span(
                 &ctx.module().source, select_stmt.span,
                 "select statements may only be used in primitive components"
             ));
+        }
@@ @@ -584,13 +528,13 @@ impl Visitor for PassValidationLinking { @@
         Ok(())
+    }
     fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {
         // Check if "return" occurs within a function
         let stmt = &ctx.heap[id];
-        if !self.def_type.is_function() {
+        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"
             ));
+        }
@@ @@ -616,13 +560,13 @@ impl Visitor for PassValidationLinking { @@
         Ok(())
+    }
     fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {
         // Make sure the new statement occurs inside a composite component
-        if !self.def_type.is_composite() {
+        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"
             ));
+        }
@@ @@ -1225,25 +1169,25 @@ impl Visitor for PassValidationLinking { @@
             },
             Method::Create => {},
             Method::Length => {},
             Method::Assert => {
                 expecting_wrapping_sync_stmt = true;
                 expecting_no_select_stmt = true;
-                if self.def_type.is_function() {
+                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::UserFunction => {},
+            Method::UserProcedure => {}
             Method::UserComponent => {
                 expecting_wrapping_new_stmt = true;
             },
+        }
         let call_expr = &mut ctx.heap[id];
@@ @@ -1252,13 +1196,13 @@ impl Visitor for PassValidationLinking { @@
             let call = &ctx.heap[id];
             let span = call.func_span;
             let name = String::from_utf8_lossy(ctx.module().source.section_at_span(span)).to_string();
             return (span, name);
+        }
         if expecting_primitive_def {
-            if !self.def_type.is_primitive() {
+            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)
                 ));
+            }
@@ @@ -1300,17 +1244,16 @@ impl Visitor for PassValidationLinking { @@
                     "only components can be instantiated, this is a function"
                 ));
+            }
+        }
         // Check the number of arguments
-        let call_definition = ctx.types.get_base_definition(&call_expr.definition).unwrap();
+        let call_definition = ctx.types.get_base_definition(&call_expr.procedure.upcast()).unwrap();
         let num_expected_args = match &call_definition.definition {
             DefinedTypeVariant::Function(definition) => definition.arguments.len(),
             DefinedTypeVariant::Component(definition) => definition.arguments.len(),
             v => unreachable!("encountered {} type in call expression", v.type_class()),
             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;
@@ @@ -1592,13 +1535,13 @@ impl PassValidationLinking { @@
     /// Will NOT check parent scopes of the specified scope.
     fn checked_at_single_scope_add_local(
         &mut self, ctx: &mut Ctx, scope_id: ScopeId, relative_pos: i32, new_variable_id: VariableId
     ) -> Result<(), ParseError> {
         // Check the symbol table for conflicts
+        {
-            let cur_scope = SymbolScope::Definition(self.def_type.definition_id());
+            let cur_scope = SymbolScope::Definition(self.proc_id.upcast());
             let ident = &ctx.heap[new_variable_id].identifier;
             if let Some(symbol) = ctx.symbols.get_symbol_by_name(cur_scope, &ident.value.as_bytes()) {
                 return Err(ParseError::new_error_str_at_span(
                     &ctx.module().source, ident.span,
                     "local variable declaration conflicts with symbol"
                 ).with_info_str_at_span(

src/protocol/parser/type_table.rs

➞

Show inline comments

@@ @@ -33,59 +33,24 @@ @@
+ *
  * As a final bit of global documentation: non-polymorphic types will always
  * have one "monomorph" entry. This contains the non-polymorphic type's memory
  * layout.
  */
 use std::fmt::{Formatter, Result as FmtResult};
 use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use crate::protocol::ast::*;
 use crate::protocol::parser::symbol_table::SymbolScope;
 use crate::protocol::input_source::ParseError;
 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 => "union",
             TypeClass::Struct => "struct",
             TypeClass::Function => "function",
             TypeClass::Component => "component",
+        }
+    }
     pub(crate) fn is_data_type(&self) -> bool {
         match self {
             TypeClass::Enum | TypeClass::Union | TypeClass::Struct => true,
             TypeClass::Function | TypeClass::Component => false,
+        }
+    }
+}
 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
@@ @@ -99,45 +64,43 @@ pub struct DefinedType { @@
+}
 pub enum DefinedTypeVariant {
     Enum(EnumType),
     Union(UnionType),
     Struct(StructType),
     Function(FunctionType),
     Component(ComponentType)
     Procedure(ProcedureType),
+}
 impl DefinedTypeVariant {
     pub(crate) fn type_class(&self) -> TypeClass {
     pub(crate) fn is_data_type(&self) -> bool {
         use DefinedTypeVariant as DTV;
         match self {
             DefinedTypeVariant::Enum(_) => TypeClass::Enum,
             DefinedTypeVariant::Union(_) => TypeClass::Union,
             DefinedTypeVariant::Struct(_) => TypeClass::Struct,
             DefinedTypeVariant::Function(_) => TypeClass::Function,
             DefinedTypeVariant::Component(_) => TypeClass::Component
             DTV::Struct(_) | DTV::Enum(_) | DTV::Union(_) => return true,
             DTV::Procedure(_) => return false,
+        }
+    }
     pub(crate) fn as_struct(&self) -> &StructType {
         match self {
             DefinedTypeVariant::Struct(v) => v,
-            _ => unreachable!("Cannot convert {} to struct variant", self.type_class())
             _ => unreachable!()
+        }
+    }
     pub(crate) fn as_enum(&self) -> &EnumType {
         match self {
             DefinedTypeVariant::Enum(v) => v,
-            _ => unreachable!("Cannot convert {} to enum variant", self.type_class())
             _ => unreachable!()
+        }
+    }
     pub(crate) fn as_union(&self) -> &UnionType {
         match self {
             DefinedTypeVariant::Union(v) => v,
-            _ => unreachable!("Cannot convert {} to union variant", self.type_class())
             _ => unreachable!()
+        }
+    }
+}
 pub struct PolymorphicVariable {
     pub(crate) identifier: Identifier,
@@ @@ -194,25 +157,20 @@ pub struct StructType { @@
 pub struct StructField {
     pub identifier: Identifier,
     pub parser_type: ParserType,
+}
 /// `FunctionType` is what you expect it to be: a particular function's
 /// signature.
 pub struct FunctionType {
     pub return_type: ParserType,
     pub arguments: Vec<FunctionArgument>,
+}
 pub struct ComponentType {
     pub variant: ComponentVariant,
     pub arguments: Vec<FunctionArgument>,
 /// `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 FunctionArgument {
+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
@@ @@ -671,14 +629,13 @@ impl TypeTable { @@
             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::Function(_) => self.build_base_function_definition(modules, ctx, definition_id)?,
                 Definition::Component(_) => self.build_base_component_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;
@@ @@ -688,13 +645,13 @@ impl TypeTable { @@
         // 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.type_class().is_data_type() || !poly_type.poly_vars.is_empty() {
             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)];
@@ @@ -997,113 +954,70 @@ impl TypeTable { @@
             is_polymorph
         });
         return Ok(())
+    }
     /// Builds base function type.
     fn build_base_function_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
     /// Builds base procedure type.
     fn build_base_procedure_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.definition_lookup.contains_key(&definition_id), "base function already built");
-        let definition = ctx.heap[definition_id].as_function();
+        let definition = ctx.heap[definition_id].as_procedure();
         let root_id = definition.defined_in;
         // Check and construct return types and argument types.
         Self::check_member_parser_type(
             modules, ctx, root_id, &definition.return_type, definition.builtin
         )?;
         let mut arguments = Vec::with_capacity(definition.parameters.len());
         for parameter_id in &definition.parameters {
             let parameter = &ctx.heap[*parameter_id];
         if let Some(return_type) = &definition.return_type {
             Self::check_member_parser_type(
-                modules, ctx, root_id, &parameter.parser_type, definition.builtin
+                modules, ctx, root_id, return_type, definition.builtin
             )?;
             arguments.push(FunctionArgument{
                 identifier: parameter.identifier.clone(),
                 parser_type: parameter.parser_type.clone(),
             });
+        }
         // Check conflict of identifiers
         Self::check_identifier_collision(
             modules, root_id, &arguments, |arg| &arg.identifier, "function argument"
         )?;
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct internal representation of function type
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         Self::mark_used_polymorphic_variables(&mut poly_vars, &definition.return_type);
         for argument in &arguments {
             Self::mark_used_polymorphic_variables(&mut poly_vars, &argument.parser_type);
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.definition_lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Function(FunctionType{ return_type: definition.return_type.clone(), arguments }),
             poly_vars,
             is_polymorph
         });
         return Ok(());
+    }
     /// Builds base component type.
     fn build_base_component_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {
         debug_assert!(!self.definition_lookup.contains_key(&definition_id), "base component already built");
         let definition = &ctx.heap[definition_id].as_component();
         let root_id = definition.defined_in;
         // Check the argument types
         let mut arguments = Vec::with_capacity(definition.parameters.len());
         for parameter_id in &definition.parameters {
             let parameter = &ctx.heap[*parameter_id];
             Self::check_member_parser_type(
-                modules, ctx, root_id, &parameter.parser_type, false
+                modules, ctx, root_id, &parameter.parser_type, definition.builtin
             )?;
-            arguments.push(FunctionArgument{
+            arguments.push(ProcedureArgument{
                 identifier: parameter.identifier.clone(),
                 parser_type: parameter.parser_type.clone(),
             });
+        }
         // Check conflict of identifiers
         Self::check_identifier_collision(
-            modules, root_id, &arguments, |arg| &arg.identifier, "connector argument"
+            modules, root_id, &arguments, |arg| &arg.identifier, "procedure argument"
         )?;
         Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;
         // Construct internal representation of component
         // TODO: Marking used polymorphic variables on procedures requires
         //  making sure that each is used in the body. For now, mark them all
         //  as required.
         // Construct internal representation of function type
         // TODO: Marking used polymorphic variables should take statements in
         //  the body into account. But currently we don't. Hence mark them all
         //  as being in-use. Note to self: true condition should be that the
         //  polymorphic variables are used in places where the resulting types
         //  are themselves truly polymorphic types (e.g. not a phantom type).
         let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);
         // for argument in &arguments {
         //     Self::mark_used_polymorphic_variables(&mut poly_vars, &argument.parser_type);
         // }
         for poly_var in &mut poly_vars {
             poly_var.is_in_use = true;
+        }
         let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);
         self.definition_lookup.insert(definition_id, DefinedType{
             ast_root: root_id,
             ast_definition: definition_id,
             definition: DefinedTypeVariant::Component(ComponentType{ variant: definition.variant, arguments }),
             definition: DefinedTypeVariant::Procedure(ProcedureType{
                 kind: definition.kind,
                 return_type: definition.return_type.clone(),
                 arguments
             }),
             poly_vars,
             is_polymorph
         });
         Ok(())
+        return Ok(());
+    }
     /// Will check if the member type (field of a struct, embedded type in a
     /// union variant) is valid.
     fn check_member_parser_type(
         modules: &[Module], ctx: &PassCtx, base_definition_root_id: RootId,
@@ @@ -1547,21 +1461,23 @@ impl TypeTable { @@
         let (definition_id, type_id) = match &concrete_type.parts[0] {
             CTP::Tuple(_) => {
                 Self::set_search_key_to_tuple(mono_key, definition_map, &concrete_type.parts);
                 let type_id = mono_type_map.get(&mono_key).copied();
                 (DefinitionId::new_invalid(), type_id)
             },
             CTP::Instance(definition_id, _) |
             CTP::Function(definition_id, _) |
             CTP::Component(definition_id, _) => {
             CTP::Instance(definition_id, _) => {
                 let definition_type = definition_map.get(definition_id).unwrap();
                 mono_key.set(&concrete_type.parts, &definition_type.poly_vars);
                 let type_id = mono_type_map.get(&mono_key).copied();
                 (*definition_id, type_id)
             },
             CTP::Function(_, _) |
             CTP::Component(_, _) => {
                 todo!("function pointers")
             },
             _ => {
                 return TypeLoopResult::TypeExists
             },
         };
         if let Some(type_id) = type_id {
@@ @@ -1686,13 +1602,13 @@ impl TypeTable { @@
                         self.mono_types.push(MonoType::new_empty(type_id, concrete_type, MonoTypeVariant::Struct(StructMonomorph{
                             fields: mono_fields,
                         })));
                         type_id
                     },
-                    DTV::Function(_) | DTV::Component(_) => {
+                    DTV::Procedure(_) => {
                         unreachable!("pushing type resolving breadcrumb for procedure type")
                     },
                 };
                 type_id
             },
     *offset &= !(alignment_min_1);
+}
 #[inline]
 fn get_concrete_type_definition(concrete_parts: &[ConcreteTypePart]) -> Option<DefinitionId> {
     match concrete_parts[0] {
         ConcreteTypePart::Instance(definition_id, _) |
         ConcreteTypePart::Instance(definition_id, _) => {
             return Some(definition_id)
         },
         ConcreteTypePart::Function(definition_id, _) |
         ConcreteTypePart::Component(definition_id, _) => {
             return Some(definition_id);
+            return Some(definition_id.upcast());
         },
         _ => {
             return None;
         },
+    }
+}
@@ \ No newline at end of file @@

src/protocol/parser/visitor.rs

➞

Show inline comments

@@ @@ -134,19 +134,15 @@ macro_rules! visitor_recursive_definition_impl { @@
                 $this.visit_union_definition($ctx, def)
             },
             Definition::Struct(def) => {
                 let def = def.this;
                 $this.visit_struct_definition($ctx, def)
             },
-            Definition::Component(def) => {
+            Definition::Procedure(def) => {
                 let def = def.this;
                 $this.visit_component_definition($ctx, def)
             },
             Definition::Function(def) => {
                 let def = def.this;
                 $this.visit_function_definition($ctx, def)
                 $this.visit_procedure_definition($ctx, def)
             },
+        }
+    }
+}
 macro_rules! visitor_recursive_expression_impl {
@@ @@ -235,14 +231,13 @@ pub(crate) trait Visitor { @@
+    }
     // --- enum variant handling
     fn visit_enum_definition(&mut self, _ctx: &mut Ctx, _id: EnumDefinitionId) -> VisitorResult { Ok(()) }
     fn visit_union_definition(&mut self, _ctx: &mut Ctx, _id: UnionDefinitionId) -> VisitorResult{ Ok(()) }
     fn visit_struct_definition(&mut self, _ctx: &mut Ctx, _id: StructDefinitionId) -> VisitorResult { Ok(()) }
     fn visit_component_definition(&mut self, _ctx: &mut Ctx, _id: ComponentDefinitionId) -> VisitorResult { Ok(()) }
     fn visit_function_definition(&mut self, _ctx: &mut Ctx, _id: FunctionDefinitionId) -> VisitorResult { Ok(()) }
     fn visit_procedure_definition(&mut self, _ctx: &mut Ctx, _id: ProcedureDefinitionId) -> VisitorResult { Ok(()) }
     // Statements
     // --- enum matching
     fn visit_stmt(&mut self, ctx: &mut Ctx, id: StatementId) -> VisitorResult {
         return visitor_recursive_statement_impl!(self, &ctx.heap[id], ctx, Ok(()));
+    }

src/protocol/tests/utils.rs

➞

Show inline comments

@@ @@ -215,13 +215,13 @@ impl AstOkTester { @@
         self
+    }
     pub(crate) fn for_function<F: FnOnce(FunctionTester)>(self, name: &str, f: F) -> Self {
         let mut found = false;
         for definition in self.heap.definitions.iter() {
-            if let Definition::Function(definition) = definition {
+            if let Definition::Procedure(definition) = definition {
                 if definition.identifier.value.as_str() != name {
                     continue;
+                }
                 // Found function
                 let tester = FunctionTester::new(self.ctx(), definition);
@@ @@ -504,17 +504,17 @@ impl<'a> UnionTester<'a> { @@
+        v
+    }
+}
 pub(crate) struct FunctionTester<'a> {
     ctx: TestCtx<'a>,
-    def: &'a FunctionDefinition,
+    def: &'a ProcedureDefinition,
+}
 impl<'a> FunctionTester<'a> {
-    fn new(ctx: TestCtx<'a>, def: &'a FunctionDefinition) -> Self {
+    fn new(ctx: TestCtx<'a>, def: &'a ProcedureDefinition) -> Self {
         Self{ ctx, def }
+    }
     pub(crate) fn for_variable<F: Fn(VariableTester)>(self, name: &str, f: F) -> Self {
         // Seek through the blocks in order to find the variable
         let wrapping_scope = seek_scope(
@@ @@ -697,17 +697,17 @@ impl<'a> FunctionTester<'a> { @@
+    }
     fn eval_until_end(&self) -> (Prompt, Result<EvalContinuation, EvalError>) {
         use crate::protocol::*;
         // Assuming the function is not polymorphic
-        let definition_id = self.def.this.upcast();
         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, &func_type).unwrap();
+        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, self.def.this.upcast(), mono_index, ValueGroup::new_stack(Vec::new()));
+        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),
@@ @@ -803,20 +803,17 @@ impl<'a> ExpressionTester<'a> { @@
             self.expr
+        )
+    }
+}
 fn get_procedure_monomorph<'a>(heap: &Heap, types: &'a TypeTable, definition_id: DefinitionId) -> &'a ProcedureMonomorph {
     let ast_definition = &heap[definition_id];
     let func_type = if ast_definition.is_function() {
         [ConcreteTypePart::Function(definition_id, 0)]
     } else if ast_definition.is_component() {
         [ConcreteTypePart::Component(definition_id, 0)]
     let ast_definition = heap[definition_id].as_procedure();
     let func_type = if ast_definition.kind == ProcedureKind::Function {
         [ConcreteTypePart::Function(ast_definition.this, 0)]
     } else {
         assert!(false);
         unreachable!()
         [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
@@ @@ -925,16 +922,20 @@ impl<'a> ErrorTester<'a> { @@
 fn has_equal_num_monomorphs(ctx: TestCtx, num: usize, definition_id: DefinitionId) -> (bool, usize) {
     // Again: inefficient, but its testing code
     let mut num_on_type = 0;
     for mono in &ctx.types.mono_types {
         match &mono.concrete_type.parts[0] {
             ConcreteTypePart::Instance(def_id, _) |
             ConcreteTypePart::Instance(def_id, _) => {
                 if *def_id == definition_id {
                     num_on_type += 1;
+                }
+            }
             ConcreteTypePart::Function(def_id, _) |
             ConcreteTypePart::Component(def_id, _) => {
-                if *def_id == definition_id {
+                if def_id.upcast() == definition_id {
                     num_on_type += 1;
+                }
             },
             _ => {},
         };
+    }
+        }
         full_buffer.push('"');
     };
     // Bit wasteful, but this is (temporary?) testing code:
-    for (mono_idx, mono) in ctx.types.mono_types.iter().enumerate() {
+    for (_mono_idx, mono) in ctx.types.mono_types.iter().enumerate() {
         let got_definition_id = match &mono.concrete_type.parts[0] {
-            ConcreteTypePart::Instance(v, _) |
+            ConcreteTypePart::Instance(v, _) => *v,
             ConcreteTypePart::Function(v, _) |
-            ConcreteTypePart::Component(v, _) => *v,
+            ConcreteTypePart::Component(v, _) => v.upcast(),
             _ => DefinitionId::new_invalid(),
         };
         if got_definition_id == definition_id {
             append_to_full_buffer(&mono.concrete_type, mono.type_id);
+        }
+    }

src/runtime2/component/component_pdl.rs

➞

Show inline comments

 use crate::protocol::*;
-use crate::protocol::ast::DefinitionId;
+use crate::protocol::ast::ProcedureDefinitionId;
 use crate::protocol::eval::{
     PortId as EvalPortId, Prompt,
     ValueGroup, Value,
     EvalContinuation, EvalResult, EvalError
 };
@@ @@ -595,13 +595,13 @@ impl CompPDL { @@
+        }
+    }
     fn create_component_and_transfer_ports(
         &mut self,
         sched_ctx: &SchedulerCtx, creator_ctx: &mut CompCtx,
-        definition_id: DefinitionId, type_id: TypeId, mut arguments: ValueGroup
+        definition_id: ProcedureDefinitionId, type_id: TypeId, mut arguments: ValueGroup
     ) {
         struct PortPair{
             creator_handle: LocalPortHandle,
             creator_id: PortId,
             created_handle: LocalPortHandle,
             created_id: PortId,

0 comments (0 inline, 0 general)