diff --git a/src/protocol/ast.rs b/src/protocol/ast.rs index 3bcc0b525893c980586cd57246693feb65892865..5278ba7082d2068751b6a24eb002b51d53c1b266 100644 --- a/src/protocol/ast.rs +++ b/src/protocol/ast.rs @@ -1009,8 +1009,7 @@ impl UnionDefinition { #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum ProcedureKind { Function, // with return type - Primitive, // without return type - Composite, + Component, } /// Monomorphed instantiation of a procedure (or the sole instantiation of a diff --git a/src/protocol/parser/pass_definitions.rs b/src/protocol/parser/pass_definitions.rs index f1daca6c3081615e0dee6cdde1a16065d2eaf752..fa5d495991b9892f9ffaf71abd3045ce444a3ba8 100644 --- a/src/protocol/parser/pass_definitions.rs +++ b/src/protocol/parser/pass_definitions.rs @@ -98,7 +98,7 @@ impl PassDefinitions { Some(KW_ENUM) => self.visit_enum_definition(module, &mut iter, ctx)?, Some(KW_UNION) => self.visit_union_definition(module, &mut iter, ctx)?, Some(KW_FUNCTION) => self.visit_function_definition(module, &mut iter, ctx)?, - Some(KW_PRIMITIVE) | Some(KW_COMPOSITE) => self.visit_component_definition(module, &mut iter, ctx)?, + Some(KW_COMPONENT) => self.visit_component_definition(module, &mut iter, ctx)?, _ => return Err(ParseError::new_error_str_at_pos( &module.source, iter.last_valid_pos(), "unexpected symbol, expected a keyword marking the start of a definition" @@ -292,13 +292,13 @@ impl PassDefinitions { Ok(()) } - + fn visit_component_definition( &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx ) -> Result<(), ParseError> { // Consume component variant and name - let (_variant_text, _) = consume_any_ident(&module.source, iter)?; - debug_assert!(_variant_text == KW_PRIMITIVE || _variant_text == KW_COMPOSITE); + let (_component_text, _) = consume_any_ident(&module.source, iter)?; + debug_assert!(_component_text == KW_COMPONENT); let (ident_text, _) = consume_ident(&module.source, iter)?; // Retrieve preallocated definition @@ -390,7 +390,7 @@ impl PassDefinitions { let source = match kind { ProcedureKind::Function => ProcedureSource::FuncUserDefined, - ProcedureKind::Primitive | ProcedureKind::Composite => + ProcedureKind::Component => ProcedureSource::CompUserDefined, }; diff --git a/src/protocol/parser/pass_symbols.rs b/src/protocol/parser/pass_symbols.rs index 2688658feb17f4d0e48c04846443c44f55b7a46c..53570356c980c4f4b580aa57ee713a5123c28ab8 100644 --- a/src/protocol/parser/pass_symbols.rs +++ b/src/protocol/parser/pass_symbols.rs @@ -237,14 +237,9 @@ impl PassSymbols { definition_class = DefinitionClass::Function; ast_definition_id = proc_def_id.upcast(); }, - KW_PRIMITIVE | KW_COMPOSITE => { - let procedure_kind = if kw_text == KW_PRIMITIVE { - ProcedureKind::Primitive - } else { - ProcedureKind::Composite - }; + KW_COMPONENT => { let proc_def_id = ctx.heap.alloc_procedure_definition(|this| { - ProcedureDefinition::new_empty(this, module.root_id, procedure_kind, identifier, poly_vars) + ProcedureDefinition::new_empty(this, module.root_id, ProcedureKind::Component, identifier, poly_vars) }); definition_class = DefinitionClass::Component; ast_definition_id = proc_def_id.upcast(); diff --git a/src/protocol/parser/pass_tokenizer.rs b/src/protocol/parser/pass_tokenizer.rs index c611c9c4dc6b79e5d39c2f23c19a8742c7f8db3c..4b79f6b518aa0dbcccea1094491c81cd3da53a25 100644 --- a/src/protocol/parser/pass_tokenizer.rs +++ b/src/protocol/parser/pass_tokenizer.rs @@ -623,8 +623,7 @@ fn demarks_symbol(ident: &[u8]) -> bool { ident == KW_ENUM || ident == KW_UNION || ident == KW_FUNCTION || - ident == KW_PRIMITIVE || - ident == KW_COMPOSITE + ident == KW_COMPONENT } #[inline] diff --git a/src/protocol/parser/pass_validation_linking.rs b/src/protocol/parser/pass_validation_linking.rs index ae2f403e976a52ca8b56971f1b892e21f74264a8..79cd33511254851af711a18539f2a37dcd5c5aac 100644 --- a/src/protocol/parser/pass_validation_linking.rs +++ b/src/protocol/parser/pass_validation_linking.rs @@ -400,10 +400,10 @@ impl Visitor for PassValidationLinking { )); } - if self.proc_kind != ProcedureKind::Primitive { + if self.proc_kind != ProcedureKind::Component { return Err(ParseError::new_error_str_at_span( &ctx.module().source, cur_sync_span, - "synchronous statements may only be used in primitive components" + "synchronous statements may only be used in components" )); } @@ -472,10 +472,10 @@ impl Visitor for PassValidationLinking { )); } - if self.proc_kind != ProcedureKind::Primitive { + if self.proc_kind != ProcedureKind::Component { return Err(ParseError::new_error_str_at_span( &ctx.module().source, select_stmt.span, - "select statements may only be used in primitive components" + "select statements may only be used in components" )); } @@ -558,12 +558,12 @@ impl Visitor for PassValidationLinking { } fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult { - // Make sure the new statement occurs inside a composite component - if self.proc_kind != ProcedureKind::Composite { + // Make sure the new statement occurs inside a component + if self.proc_kind != ProcedureKind::Component { 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" + "instantiating components may only be done in components" )); } @@ -1113,13 +1113,11 @@ impl Visitor for PassValidationLinking { // Check whether the method is allowed to be called within the code's // context (in sync, definition type, etc.) let mut expecting_wrapping_new_stmt = false; - let mut expecting_primitive_def = false; let mut expecting_wrapping_sync_stmt = false; let mut expecting_no_select_stmt = false; match call_expr.method { Method::Get => { - expecting_primitive_def = true; expecting_wrapping_sync_stmt = true; if !self.in_select_guard.is_invalid() { // In a select guard. Take the argument (i.e. the port we're @@ -1136,12 +1134,10 @@ impl Visitor for PassValidationLinking { } }, Method::Put => { - expecting_primitive_def = true; expecting_wrapping_sync_stmt = true; expecting_no_select_stmt = true; }, Method::Fires => { - expecting_primitive_def = true; expecting_wrapping_sync_stmt = true; }, Method::Create => {}, @@ -1179,15 +1175,6 @@ impl Visitor for PassValidationLinking { let name = String::from_utf8_lossy(ctx.module().source.section_at_span(span)).to_string(); return (span, name); } - if expecting_primitive_def { - if self.proc_kind != ProcedureKind::Primitive { - let (call_span, func_name) = get_span_and_name(ctx, id); - return Err(ParseError::new_error_at_span( - &ctx.module().source, call_span, - format!("a call to '{}' may only occur in primitive component definitions", func_name) - )); - } - } if expecting_wrapping_sync_stmt { if self.in_sync.is_invalid() { diff --git a/src/protocol/parser/token_parsing.rs b/src/protocol/parser/token_parsing.rs index 28663793ff335f24a9db786c9514ece91f92536b..08abe9b338ae2931062d32064ec6016e5d6fcf70 100644 --- a/src/protocol/parser/token_parsing.rs +++ b/src/protocol/parser/token_parsing.rs @@ -17,8 +17,7 @@ pub(crate) const KW_STRUCT: &'static [u8] = b"struct"; pub(crate) const KW_ENUM: &'static [u8] = b"enum"; pub(crate) const KW_UNION: &'static [u8] = b"union"; pub(crate) const KW_FUNCTION: &'static [u8] = b"func"; -pub(crate) const KW_PRIMITIVE: &'static [u8] = b"primitive"; -pub(crate) const KW_COMPOSITE: &'static [u8] = b"composite"; +pub(crate) const KW_COMPONENT: &'static [u8] = b"comp"; pub(crate) const KW_IMPORT: &'static [u8] = b"import"; // Keywords - literals @@ -560,7 +559,7 @@ pub(crate) fn consume_ident_interned( fn is_reserved_definition_keyword(text: &[u8]) -> bool { match text { - KW_STRUCT | KW_ENUM | KW_UNION | KW_FUNCTION | KW_PRIMITIVE | KW_COMPOSITE => true, + KW_STRUCT | KW_ENUM | KW_UNION | KW_FUNCTION | KW_COMPONENT => true, _ => false, } } diff --git a/src/runtime2/component/component.rs b/src/runtime2/component/component.rs index d5712961e4599ebea7ed0b73bbdf3aa03a2d2c81..525613092199b6baf777c0a2e24ebe76e8f20631 100644 --- a/src/runtime2/component/component.rs +++ b/src/runtime2/component/component.rs @@ -234,7 +234,7 @@ pub(crate) fn create_component( arguments: ValueGroup, num_ports: usize ) -> Box { let definition = &protocol.heap[definition_id]; - debug_assert!(definition.kind == ProcedureKind::Primitive || definition.kind == ProcedureKind::Composite); + debug_assert_eq!(definition.kind, ProcedureKind::Component); if definition.source.is_builtin() { // Builtin component