diff --git a/src/protocol/inputsource.rs b/src/protocol/inputsource.rs index b070fe7e5d57d55cb2e4a28692ddf265c1364feb..48519ee2f26fb974a5ba92c63197b69d041d50a1 100644 --- a/src/protocol/inputsource.rs +++ b/src/protocol/inputsource.rs @@ -87,9 +87,6 @@ impl InputSource { self.column = pos.column; self.offset = pos.offset; } - // pub fn error(&self, message: S) -> ParseError { - // self.pos().parse_error(message) - // } pub fn is_eof(&self) -> bool { self.next() == None } @@ -167,9 +164,6 @@ impl InputPosition { } &source.input[start..end] } - // fn parse_error(&self, message: S) -> ParseError { - // ParseError { position: *self, message: message.to_string(), backtrace: Backtrace::new() } - // } fn eval_error(&self, message: S) -> EvalError { EvalError { position: *self, message: message.to_string(), backtrace: Backtrace::new() } } @@ -278,11 +272,11 @@ impl fmt::Display for ParseErrorStatement { } #[derive(Debug)] -pub struct ParseError2 { +pub struct ParseError { pub(crate) statements: Vec } -impl fmt::Display for ParseError2 { +impl fmt::Display for ParseError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { if self.statements.is_empty() { return Ok(()) @@ -298,7 +292,7 @@ impl fmt::Display for ParseError2 { } } -impl ParseError2 { +impl ParseError { pub fn empty() -> Self { Self{ statements: Vec::new() } } diff --git a/src/protocol/lexer.rs b/src/protocol/lexer.rs index 2d6b024a6d704ae7f38caf46712a5b9b72cc2835..f31625a0588a6bd1b3a7e2641d7dee81d138a572 100644 --- a/src/protocol/lexer.rs +++ b/src/protocol/lexer.rs @@ -116,10 +116,10 @@ impl Lexer<'_> { pub fn new(source: &mut InputSource) -> Lexer { Lexer { source, level: 0 } } - fn error_at_pos(&self, msg: &str) -> ParseError2 { - ParseError2::new_error(self.source, self.source.pos(), msg) + fn error_at_pos(&self, msg: &str) -> ParseError { + ParseError::new_error(self.source, self.source.pos(), msg) } - fn consume_line(&mut self) -> Result, ParseError2> { + fn consume_line(&mut self) -> Result, ParseError> { let mut result: Vec = Vec::new(); let mut next = self.source.next(); while next.is_some() && next != Some(b'\n') && next != Some(b'\r') { @@ -138,7 +138,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_whitespace(&mut self, expected: bool) -> Result<(), ParseError2> { + fn consume_whitespace(&mut self, expected: bool) -> Result<(), ParseError> { let mut found = false; let mut next = self.source.next(); while next.is_some() { @@ -208,7 +208,7 @@ impl Lexer<'_> { if next.is_none() { return true; } return !is_ident_rest(next); } - fn consume_keyword(&mut self, keyword: &[u8]) -> Result<(), ParseError2> { + fn consume_keyword(&mut self, keyword: &[u8]) -> Result<(), ParseError> { let len = keyword.len(); for i in 0..len { let expected = Some(lowercase(keyword[i])); @@ -228,7 +228,7 @@ impl Lexer<'_> { fn has_string(&self, string: &[u8]) -> bool { self.source.has(string) } - fn consume_string(&mut self, string: &[u8]) -> Result<(), ParseError2> { + fn consume_string(&mut self, string: &[u8]) -> Result<(), ParseError> { let len = string.len(); for i in 0..len { let expected = Some(string[i]); @@ -247,8 +247,8 @@ impl Lexer<'_> { /// returned. fn consume_comma_separated( &mut self, h: &mut Heap, open: u8, close: u8, expected_end_msg: &str, func: F - ) -> Result>, ParseError2> - where F: Fn(&mut Lexer, &mut Heap) -> Result + ) -> Result>, ParseError> + where F: Fn(&mut Lexer, &mut Heap) -> Result { if Some(open) != self.source.next() { return Ok(None) @@ -264,7 +264,7 @@ impl Lexer<'_> { self.source.consume(); break; } else if !had_comma { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &self.source, self.source.pos(), expected_end_msg )); } @@ -314,7 +314,7 @@ impl Lexer<'_> { } } } - fn consume_ident(&mut self) -> Result, ParseError2> { + fn consume_ident(&mut self) -> Result, ParseError> { if !self.has_identifier() { return Err(self.error_at_pos("Expected identifier")); } @@ -333,7 +333,7 @@ impl Lexer<'_> { fn has_integer(&mut self) -> bool { is_integer_start(self.source.next()) } - fn consume_integer(&mut self) -> Result { + fn consume_integer(&mut self) -> Result { let position = self.source.pos(); let mut data = Vec::new(); let mut next = self.source.next(); @@ -366,7 +366,7 @@ impl Lexer<'_> { }; if let Err(_err) = parsed { - return Err(ParseError2::new_error(&self.source, position, "Invalid integer constant")); + return Err(ParseError::new_error(&self.source, position, "Invalid integer constant")); } Ok(parsed.unwrap()) @@ -426,7 +426,7 @@ impl Lexer<'_> { let next = self.source.next(); is_ident_start(next) } - fn consume_identifier(&mut self) -> Result { + fn consume_identifier(&mut self) -> Result { if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() { return Err(self.error_at_pos("Expected identifier")); } @@ -434,7 +434,7 @@ impl Lexer<'_> { let value = self.consume_ident()?; Ok(Identifier{ position, value }) } - fn consume_identifier_spilled(&mut self) -> Result<(), ParseError2> { + fn consume_identifier_spilled(&mut self) -> Result<(), ParseError> { if self.has_statement_keyword() || self.has_type_keyword() || self.has_builtin_keyword() { return Err(self.error_at_pos("Expected identifier")); } @@ -442,7 +442,7 @@ impl Lexer<'_> { Ok(()) } - fn consume_namespaced_identifier(&mut self, h: &mut Heap) -> Result { + fn consume_namespaced_identifier(&mut self, h: &mut Heap) -> Result { if self.has_reserved() { return Err(self.error_at_pos("Encountered reserved keyword")); } @@ -456,7 +456,7 @@ impl Lexer<'_> { fn consume_part( l: &mut Lexer, h: &mut Heap, ident: &mut NamespacedIdentifier, backup_pos: &mut InputPosition - ) -> Result<(), ParseError2> { + ) -> Result<(), ParseError> { // Consume identifier if !ident.value.is_empty() { ident.value.extend(b"::"); @@ -514,14 +514,14 @@ impl Lexer<'_> { Ok(ident) } - fn consume_namespaced_identifier_spilled(&mut self) -> Result<(), ParseError2> { + fn consume_namespaced_identifier_spilled(&mut self) -> Result<(), ParseError> { if self.has_reserved() { return Err(self.error_at_pos("Encountered reserved keyword")); } debug_log!("consume_nsident2_spilled: {}", debug_line!(self.source)); - fn consume_part_spilled(l: &mut Lexer, backup_pos: &mut InputPosition) -> Result<(), ParseError2> { + fn consume_part_spilled(l: &mut Lexer, backup_pos: &mut InputPosition) -> Result<(), ParseError> { l.consume_ident()?; *backup_pos = l.source.pos(); l.consume_whitespace(false)?; @@ -552,7 +552,7 @@ impl Lexer<'_> { /// Consumes a type definition. When called the input position should be at /// the type specification. When done the input position will be at the end /// of the type specifications (hence may be at whitespace). - fn consume_type2(&mut self, h: &mut Heap, allow_inference: bool) -> Result { + fn consume_type(&mut self, h: &mut Heap, allow_inference: bool) -> Result { // Small helper function to convert in/out polymorphic arguments. Not // pretty, but return boolean is true if the error is due to inference // not being allowed @@ -577,7 +577,7 @@ impl Lexer<'_> { }; // Consume the type - debug_log!("consume_type2: {}", debug_line!(self.source)); + debug_log!("consume_type: {}", debug_line!(self.source)); let pos = self.source.pos(); let parser_type_variant = if self.has_keyword(b"msg") { self.consume_keyword(b"msg")?; @@ -602,7 +602,7 @@ impl Lexer<'_> { ParserTypeVariant::String } else if self.has_keyword(b"auto") { if !allow_inference { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &self.source, pos, "Type inference is not allowed here" )); @@ -622,7 +622,7 @@ impl Lexer<'_> { } else { "Type 'in' only allows for 1 polymorphic argument" }; - ParseError2::new_error(&self.source, pos, msg) + ParseError::new_error(&self.source, pos, msg) })?; ParserTypeVariant::Input(poly_arg) } else if self.has_keyword(b"out") { @@ -635,7 +635,7 @@ impl Lexer<'_> { } else { "Type 'out' only allows for 1 polymorphic argument, but {} were specified" }; - ParseError2::new_error(&self.source, pos, msg) + ParseError::new_error(&self.source, pos, msg) })?; ParserTypeVariant::Output(poly_arg) } else { @@ -650,7 +650,7 @@ impl Lexer<'_> { if !parser_type_variant.supports_polymorphic_args() { self.consume_whitespace(false)?; if let Some(b'<') = self.source.next() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &self.source, self.source.pos(), "This type does not allow polymorphic arguments" )); @@ -681,7 +681,7 @@ impl Lexer<'_> { // In case we're dealing with another array self.consume_whitespace(false)?; } else { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &self.source, pos, "Expected a closing ']'" )); @@ -757,10 +757,10 @@ impl Lexer<'_> { /// Polymorphic arguments represent the specification of the parametric /// types of a polymorphic type: they specify the value of the polymorphic /// type's polymorphic variables. - fn consume_polymorphic_args(&mut self, h: &mut Heap, allow_inference: bool) -> Result>, ParseError2> { + fn consume_polymorphic_args(&mut self, h: &mut Heap, allow_inference: bool) -> Result>, ParseError> { self.consume_comma_separated( h, b'<', b'>', "Expected the end of the polymorphic argument list", - |lexer, heap| lexer.consume_type2(heap, allow_inference) + |lexer, heap| lexer.consume_type(heap, allow_inference) ) } @@ -770,7 +770,7 @@ impl Lexer<'_> { /// delimiters and the polymorphic variables are consumed. Otherwise the /// input position will stay where it is. If no polymorphic variables are /// present then an empty vector will be returned. - fn consume_polymorphic_vars(&mut self, h: &mut Heap) -> Result, ParseError2> { + fn consume_polymorphic_vars(&mut self, h: &mut Heap) -> Result, ParseError> { let backup_pos = self.source.pos(); match self.consume_comma_separated( h, b'<', b'>', "Expected the end of the polymorphic variable list", @@ -786,8 +786,8 @@ impl Lexer<'_> { // Parameters - fn consume_parameter(&mut self, h: &mut Heap) -> Result { - let parser_type = self.consume_type2(h, false)?; + fn consume_parameter(&mut self, h: &mut Heap) -> Result { + let parser_type = self.consume_type(h, false)?; self.consume_whitespace(true)?; let position = self.source.pos(); let identifier = self.consume_identifier()?; @@ -795,14 +795,14 @@ impl Lexer<'_> { h.alloc_parameter(|this| Parameter { this, position, parser_type, identifier }); Ok(id) } - fn consume_parameters(&mut self, h: &mut Heap) -> Result, ParseError2> { + fn consume_parameters(&mut self, h: &mut Heap) -> Result, ParseError> { match self.consume_comma_separated( h, b'(', b')', "Expected the end of the parameter list", |lexer, heap| lexer.consume_parameter(heap) )? { Some(params) => Ok(params), None => { - Err(ParseError2::new_error( + Err(ParseError::new_error( &self.source, self.source.pos(), "Expected a parameter list" )) @@ -814,7 +814,7 @@ impl Lexer<'_> { // Expressions // ==================== - fn consume_paren_expression(&mut self, h: &mut Heap) -> Result { + fn consume_paren_expression(&mut self, h: &mut Heap) -> Result { self.consume_string(b"(")?; self.consume_whitespace(false)?; let result = self.consume_expression(h)?; @@ -822,7 +822,7 @@ impl Lexer<'_> { self.consume_string(b")")?; Ok(result) } - fn consume_expression(&mut self, h: &mut Heap) -> Result { + fn consume_expression(&mut self, h: &mut Heap) -> Result { if self.level >= MAX_LEVEL { return Err(self.error_at_pos("Too deeply nested expression")); } @@ -831,7 +831,7 @@ impl Lexer<'_> { self.level -= 1; result } - fn consume_assignment_expression(&mut self, h: &mut Heap) -> Result { + fn consume_assignment_expression(&mut self, h: &mut Heap) -> Result { let result = self.consume_conditional_expression(h)?; self.consume_whitespace(false)?; if self.has_assignment_operator() { @@ -867,7 +867,7 @@ impl Lexer<'_> { || self.has_string(b"^=") || self.has_string(b"|=") } - fn consume_assignment_operator(&mut self) -> Result { + fn consume_assignment_operator(&mut self) -> Result { if self.has_string(b"=") { self.consume_string(b"=")?; Ok(AssignmentOperator::Set) @@ -905,7 +905,7 @@ impl Lexer<'_> { Err(self.error_at_pos("Expected assignment operator")) } } - fn consume_conditional_expression(&mut self, h: &mut Heap) -> Result { + fn consume_conditional_expression(&mut self, h: &mut Heap) -> Result { let result = self.consume_concat_expression(h)?; self.consume_whitespace(false)?; if self.has_string(b"?") { @@ -932,7 +932,7 @@ impl Lexer<'_> { Ok(result) } } - fn consume_concat_expression(&mut self, h: &mut Heap) -> Result { + fn consume_concat_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_lor_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"@") { @@ -957,7 +957,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_lor_expression(&mut self, h: &mut Heap) -> Result { + fn consume_lor_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_land_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"||") { @@ -982,7 +982,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_land_expression(&mut self, h: &mut Heap) -> Result { + fn consume_land_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_bor_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"&&") { @@ -1007,7 +1007,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_bor_expression(&mut self, h: &mut Heap) -> Result { + fn consume_bor_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_xor_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"|") && !self.has_string(b"||") && !self.has_string(b"|=") { @@ -1032,7 +1032,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_xor_expression(&mut self, h: &mut Heap) -> Result { + fn consume_xor_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_band_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"^") && !self.has_string(b"^=") { @@ -1057,7 +1057,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_band_expression(&mut self, h: &mut Heap) -> Result { + fn consume_band_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_eq_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"&") && !self.has_string(b"&&") && !self.has_string(b"&=") { @@ -1082,7 +1082,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_eq_expression(&mut self, h: &mut Heap) -> Result { + fn consume_eq_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_rel_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"==") || self.has_string(b"!=") { @@ -1113,7 +1113,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_rel_expression(&mut self, h: &mut Heap) -> Result { + fn consume_rel_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_shift_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"<=") @@ -1154,7 +1154,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_shift_expression(&mut self, h: &mut Heap) -> Result { + fn consume_shift_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_add_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"<<") && !self.has_string(b"<<=") @@ -1187,7 +1187,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_add_expression(&mut self, h: &mut Heap) -> Result { + fn consume_add_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_mul_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"+") && !self.has_string(b"+=") @@ -1220,7 +1220,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_mul_expression(&mut self, h: &mut Heap) -> Result { + fn consume_mul_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_prefix_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"*") && !self.has_string(b"*=") @@ -1257,7 +1257,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_prefix_expression(&mut self, h: &mut Heap) -> Result { + fn consume_prefix_expression(&mut self, h: &mut Heap) -> Result { if self.has_string(b"+") || self.has_string(b"-") || self.has_string(b"~") @@ -1309,7 +1309,7 @@ impl Lexer<'_> { } self.consume_postfix_expression(h) } - fn consume_postfix_expression(&mut self, h: &mut Heap) -> Result { + fn consume_postfix_expression(&mut self, h: &mut Heap) -> Result { let mut result = self.consume_primary_expression(h)?; self.consume_whitespace(false)?; while self.has_string(b"++") @@ -1420,7 +1420,7 @@ impl Lexer<'_> { } Ok(result) } - fn consume_primary_expression(&mut self, h: &mut Heap) -> Result { + fn consume_primary_expression(&mut self, h: &mut Heap) -> Result { if self.has_string(b"(") { return self.consume_paren_expression(h); } @@ -1438,7 +1438,7 @@ impl Lexer<'_> { } Ok(self.consume_variable_expression(h)?.upcast()) } - fn consume_array_expression(&mut self, h: &mut Heap) -> Result { + fn consume_array_expression(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); let mut elements = Vec::new(); self.consume_string(b"{")?; @@ -1472,7 +1472,7 @@ impl Lexer<'_> { fn consume_builtin_literal_expression( &mut self, h: &mut Heap, - ) -> Result { + ) -> Result { let position = self.source.pos(); let value; if self.has_keyword(b"null") { @@ -1528,7 +1528,7 @@ impl Lexer<'_> { return result; } - fn consume_struct_literal_expression(&mut self, h: &mut Heap) -> Result { + fn consume_struct_literal_expression(&mut self, h: &mut Heap) -> Result { // Consume identifier and polymorphic arguments debug_log!("consume_struct_literal_expression: {}", debug_line!(self.source)); let position = self.source.pos(); @@ -1549,7 +1549,7 @@ impl Lexer<'_> { } )? { Some(fields) => fields, - None => return Err(ParseError2::new_error( + None => return Err(ParseError::new_error( self.source, self.source.pos(), "A struct literal must be followed by its field values" )) @@ -1589,7 +1589,7 @@ impl Lexer<'_> { self.source.seek(backup_pos); return result; } - fn consume_call_expression(&mut self, h: &mut Heap) -> Result { + fn consume_call_expression(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); // Consume method identifier @@ -1657,7 +1657,7 @@ impl Lexer<'_> { fn consume_variable_expression( &mut self, h: &mut Heap, - ) -> Result { + ) -> Result { let position = self.source.pos(); debug_log!("consume_variable_expression: {}", debug_line!(self.source)); @@ -1686,7 +1686,7 @@ impl Lexer<'_> { /// will be wrapped in a block statement if it is not already a block /// statement. This is used to ensure that all `if`, `while` and `sync` /// statements have a block statement as body. - fn consume_statement(&mut self, h: &mut Heap, wrap_in_block: bool) -> Result { + fn consume_statement(&mut self, h: &mut Heap, wrap_in_block: bool) -> Result { if self.level >= MAX_LEVEL { return Err(self.error_at_pos("Too deeply nested statement")); } @@ -1708,7 +1708,7 @@ impl Lexer<'_> { self.source.seek(backup_pos); return result; } - fn consume_statement_impl(&mut self, h: &mut Heap, wrap_in_block: bool) -> Result { + fn consume_statement_impl(&mut self, h: &mut Heap, wrap_in_block: bool) -> Result { // Parse and allocate statement let mut must_wrap = true; let mut stmt_id = if self.has_string(b"{") { @@ -1786,7 +1786,7 @@ impl Lexer<'_> { self.source.seek(backup_pos); return result; } - fn consume_block_statement(&mut self, h: &mut Heap) -> Result { + fn consume_block_statement(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); let mut statements = Vec::new(); self.consume_string(b"{")?; @@ -1819,7 +1819,7 @@ impl Lexer<'_> { .upcast()) } } - fn consume_local_statement(&mut self, h: &mut Heap) -> Result<(LocalStatementId, Option), ParseError2> { + fn consume_local_statement(&mut self, h: &mut Heap) -> Result<(LocalStatementId, Option), ParseError> { if self.has_keyword(b"channel") { let local_id = self.consume_channel_statement(h)?.upcast(); Ok((local_id, None)) @@ -1831,7 +1831,7 @@ impl Lexer<'_> { fn consume_channel_statement( &mut self, h: &mut Heap, - ) -> Result { + ) -> Result { // Consume channel statement and polymorphic argument if specified. // Needs a tiny bit of special parsing to ensure the right amount of // whitespace is present. @@ -1846,7 +1846,7 @@ impl Lexer<'_> { this, pos: position.clone(), variant: ParserTypeVariant::Inferred, }), 1 => poly_args[0], - _ => return Err(ParseError2::new_error( + _ => return Err(ParseError::new_error( &self.source, self.source.pos(), "port construction using 'channel' accepts up to 1 polymorphic argument" )) @@ -1894,9 +1894,9 @@ impl Lexer<'_> { next: None, })) } - fn consume_memory_statement(&mut self, h: &mut Heap) -> Result<(MemoryStatementId, ExpressionStatementId), ParseError2> { + fn consume_memory_statement(&mut self, h: &mut Heap) -> Result<(MemoryStatementId, ExpressionStatementId), ParseError> { let position = self.source.pos(); - let parser_type = self.consume_type2(h, true)?; + let parser_type = self.consume_type(h, true)?; self.consume_whitespace(true)?; let identifier = self.consume_identifier()?; self.consume_whitespace(false)?; @@ -1949,7 +1949,7 @@ impl Lexer<'_> { fn consume_labeled_statement( &mut self, h: &mut Heap, - ) -> Result { + ) -> Result { let position = self.source.pos(); let label = self.consume_identifier()?; self.consume_whitespace(false)?; @@ -1965,14 +1965,14 @@ impl Lexer<'_> { in_sync: None, })) } - fn consume_skip_statement(&mut self, h: &mut Heap) -> Result { + fn consume_skip_statement(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); self.consume_keyword(b"skip")?; self.consume_whitespace(false)?; self.consume_string(b";")?; Ok(h.alloc_skip_statement(|this| SkipStatement { this, position, next: None })) } - fn consume_if_statement(&mut self, h: &mut Heap) -> Result { + fn consume_if_statement(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); self.consume_keyword(b"if")?; self.consume_whitespace(false)?; @@ -1989,7 +1989,7 @@ impl Lexer<'_> { }; Ok(h.alloc_if_statement(|this| IfStatement { this, position, test, true_body, false_body, end_if: None })) } - fn consume_while_statement(&mut self, h: &mut Heap) -> Result { + fn consume_while_statement(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); self.consume_keyword(b"while")?; self.consume_whitespace(false)?; @@ -2005,7 +2005,7 @@ impl Lexer<'_> { in_sync: None, })) } - fn consume_break_statement(&mut self, h: &mut Heap) -> Result { + fn consume_break_statement(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); self.consume_keyword(b"break")?; self.consume_whitespace(false)?; @@ -2022,7 +2022,7 @@ impl Lexer<'_> { fn consume_continue_statement( &mut self, h: &mut Heap, - ) -> Result { + ) -> Result { let position = self.source.pos(); self.consume_keyword(b"continue")?; self.consume_whitespace(false)?; @@ -2044,7 +2044,7 @@ impl Lexer<'_> { fn consume_synchronous_statement( &mut self, h: &mut Heap, - ) -> Result { + ) -> Result { let position = self.source.pos(); self.consume_keyword(b"synchronous")?; self.consume_whitespace(false)?; @@ -2065,7 +2065,7 @@ impl Lexer<'_> { parent_scope: None, })) } - fn consume_return_statement(&mut self, h: &mut Heap) -> Result { + fn consume_return_statement(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); self.consume_keyword(b"return")?; self.consume_whitespace(false)?; @@ -2078,7 +2078,7 @@ impl Lexer<'_> { self.consume_string(b";")?; Ok(h.alloc_return_statement(|this| ReturnStatement { this, position, expression })) } - fn consume_assert_statement(&mut self, h: &mut Heap) -> Result { + fn consume_assert_statement(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); self.consume_keyword(b"assert")?; self.consume_whitespace(false)?; @@ -2096,7 +2096,7 @@ impl Lexer<'_> { next: None, })) } - fn consume_goto_statement(&mut self, h: &mut Heap) -> Result { + fn consume_goto_statement(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); self.consume_keyword(b"goto")?; self.consume_whitespace(false)?; @@ -2105,7 +2105,7 @@ impl Lexer<'_> { self.consume_string(b";")?; Ok(h.alloc_goto_statement(|this| GotoStatement { this, position, label, target: None })) } - fn consume_new_statement(&mut self, h: &mut Heap) -> Result { + fn consume_new_statement(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); self.consume_keyword(b"new")?; self.consume_whitespace(false)?; @@ -2117,7 +2117,7 @@ impl Lexer<'_> { fn consume_expression_statement( &mut self, h: &mut Heap, - ) -> Result { + ) -> Result { let position = self.source.pos(); let expression = self.consume_expression(h)?; self.consume_whitespace(false)?; @@ -2140,7 +2140,7 @@ impl Lexer<'_> { || self.has_type_keyword() || self.has_identifier() } - fn consume_symbol_definition(&mut self, h: &mut Heap) -> Result { + fn consume_symbol_definition(&mut self, h: &mut Heap) -> Result { if self.has_keyword(b"struct") { Ok(self.consume_struct_definition(h)?.upcast()) } else if self.has_keyword(b"enum") { @@ -2151,7 +2151,7 @@ impl Lexer<'_> { Ok(self.consume_function_definition(h)?.upcast()) } } - fn consume_struct_definition(&mut self, h: &mut Heap) -> Result { + fn consume_struct_definition(&mut self, h: &mut Heap) -> Result { // Parse "struct" keyword, optional polyvars and its identifier let struct_pos = self.source.pos(); self.consume_keyword(b"struct")?; @@ -2166,7 +2166,7 @@ impl Lexer<'_> { h, b'{', b'}', "Expected the end of the list of struct fields", |lexer, heap| { let position = lexer.source.pos(); - let parser_type = lexer.consume_type2(heap, false)?; + let parser_type = lexer.consume_type(heap, false)?; lexer.consume_whitespace(true)?; let field = lexer.consume_identifier()?; @@ -2174,7 +2174,7 @@ impl Lexer<'_> { } )? { Some(fields) => fields, - None => return Err(ParseError2::new_error( + None => return Err(ParseError::new_error( self.source, struct_pos, "An struct definition must be followed by its fields" )), @@ -2189,7 +2189,7 @@ impl Lexer<'_> { fields, })) } - fn consume_enum_definition(&mut self, h: &mut Heap) -> Result { + fn consume_enum_definition(&mut self, h: &mut Heap) -> Result { // Parse "enum" keyword, optional polyvars and its identifier let enum_pos = self.source.pos(); self.consume_keyword(b"enum")?; @@ -2229,7 +2229,7 @@ impl Lexer<'_> { // Embedded type lexer.source.consume(); lexer.consume_whitespace(false)?; - let embedded_type = lexer.consume_type2(heap, false)?; + let embedded_type = lexer.consume_type(heap, false)?; lexer.consume_whitespace(false)?; lexer.consume_string(b")")?; EnumVariantValue::Type(embedded_type) @@ -2243,7 +2243,7 @@ impl Lexer<'_> { } )? { Some(variants) => variants, - None => return Err(ParseError2::new_error( + None => return Err(ParseError::new_error( self.source, enum_pos, "An enum definition must be followed by its variants" )), @@ -2257,7 +2257,7 @@ impl Lexer<'_> { variants, })) } - fn consume_component_definition(&mut self, h: &mut Heap) -> Result { + fn consume_component_definition(&mut self, h: &mut Heap) -> Result { // TODO: Cleanup if self.has_keyword(b"composite") { Ok(self.consume_composite_definition(h)?) @@ -2265,7 +2265,7 @@ impl Lexer<'_> { Ok(self.consume_primitive_definition(h)?) } } - fn consume_composite_definition(&mut self, h: &mut Heap) -> Result { + fn consume_composite_definition(&mut self, h: &mut Heap) -> Result { // Parse keyword, optional polyvars and the identifier let position = self.source.pos(); self.consume_keyword(b"composite")?; @@ -2291,7 +2291,7 @@ impl Lexer<'_> { body })) } - fn consume_primitive_definition(&mut self, h: &mut Heap) -> Result { + fn consume_primitive_definition(&mut self, h: &mut Heap) -> Result { // Consume keyword, optional polyvars and identifier let position = self.source.pos(); self.consume_keyword(b"primitive")?; @@ -2317,10 +2317,10 @@ impl Lexer<'_> { body })) } - fn consume_function_definition(&mut self, h: &mut Heap) -> Result { + fn consume_function_definition(&mut self, h: &mut Heap) -> Result { // Consume return type, optional polyvars and identifier let position = self.source.pos(); - let return_type = self.consume_type2(h, false)?; + let return_type = self.consume_type(h, false)?; self.consume_whitespace(true)?; let identifier = self.consume_identifier()?; self.consume_whitespace(false)?; @@ -2350,7 +2350,7 @@ impl Lexer<'_> { false } } - fn consume_pragma(&mut self, h: &mut Heap) -> Result { + fn consume_pragma(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); let next = self.source.next(); if next != Some(b'#') { @@ -2397,7 +2397,7 @@ impl Lexer<'_> { fn has_import(&self) -> bool { self.has_keyword(b"import") } - fn consume_import(&mut self, h: &mut Heap) -> Result { + fn consume_import(&mut self, h: &mut Heap) -> Result { // Parse the word "import" and the name of the module let position = self.source.pos(); self.consume_keyword(b"import")?; @@ -2537,7 +2537,7 @@ impl Lexer<'_> { self.consume_string(b";")?; Ok(import) } - pub fn consume_protocol_description(&mut self, h: &mut Heap) -> Result { + pub fn consume_protocol_description(&mut self, h: &mut Heap) -> Result { let position = self.source.pos(); let mut pragmas = Vec::new(); let mut imports = Vec::new(); diff --git a/src/protocol/parser/mod.rs b/src/protocol/parser/mod.rs index 84c8854902b43975ae27047056999e5c16911e85..2ecd781606c3c13ddfd54b1bd62533da5564bc26 100644 --- a/src/protocol/parser/mod.rs +++ b/src/protocol/parser/mod.rs @@ -47,7 +47,7 @@ impl Parser { } } - pub fn feed(&mut self, mut source: InputSource) -> Result { + pub fn feed(&mut self, mut source: InputSource) -> Result { // Lex the input source let mut lex = Lexer::new(&mut source); let pd = lex.consume_protocol_description(&mut self.heap)?; @@ -64,7 +64,7 @@ impl Parser { Pragma::Module(module) => { if !module_name.is_empty() { return Err( - ParseError2::new_error(&source, module.position, "Double definition of module name in the same file") + ParseError::new_error(&source, module.position, "Double definition of module name in the same file") .with_postfixed_info(&source, module_name_pos, "Previous definition was here") ) } @@ -75,7 +75,7 @@ impl Parser { Pragma::Version(version) => { if module_version.is_some() { return Err( - ParseError2::new_error(&source, version.position, "Double definition of module version") + ParseError::new_error(&source, version.position, "Double definition of module version") .with_postfixed_info(&source, module_version_pos, "Previous definition was here") ) } @@ -108,7 +108,7 @@ impl Parser { }; return Err( - ParseError2::new_error(&source, module_name_pos, &format!("Double definition of {} across files", module_name_msg)) + ParseError::new_error(&source, module_name_pos, &format!("Double definition of {} across files", module_name_msg)) .with_postfixed_info(&prev_module.source, prev_module_pos, "Other definition was here") ); } @@ -123,7 +123,7 @@ impl Parser { Ok(pd) } - fn resolve_symbols_and_types(&mut self) -> Result<(), ParseError2> { + fn resolve_symbols_and_types(&mut self) -> Result<(), ParseError> { // Construct the symbol table to resolve any imports and/or definitions, // then use the symbol table to actually annotate all of the imports. // If the type table is constructed correctly then all imports MUST be @@ -187,7 +187,7 @@ impl Parser { Ok(()) } - pub fn parse(&mut self) -> Result<(), ParseError2> { + pub fn parse(&mut self) -> Result<(), ParseError> { self.resolve_symbols_and_types()?; // Validate and link all modules @@ -230,7 +230,7 @@ impl Parser { for module in &self.modules { let root_id = module.root_id; if let Err((position, message)) = Self::parse_inner(&mut self.heap, root_id) { - return Err(ParseError2::new_error(&self.modules[0].source, position, &message)) + return Err(ParseError::new_error(&self.modules[0].source, position, &message)) } } diff --git a/src/protocol/parser/symbol_table.rs b/src/protocol/parser/symbol_table.rs index 48ae5e34e8c3ccb0ea825c196954a2b98bf8593b..b12a28b14736b03d1840194f7a2f9c4a21e79987 100644 --- a/src/protocol/parser/symbol_table.rs +++ b/src/protocol/parser/symbol_table.rs @@ -89,7 +89,7 @@ impl SymbolTable { Self{ module_lookup: HashMap::new(), symbol_lookup: HashMap::new() } } - pub(crate) fn build(&mut self, heap: &Heap, modules: &[LexedModule]) -> Result<(), ParseError2> { + pub(crate) fn build(&mut self, heap: &Heap, modules: &[LexedModule]) -> Result<(), ParseError> { // Sanity checks debug_assert!(self.module_lookup.is_empty()); debug_assert!(self.symbol_lookup.is_empty()); @@ -129,7 +129,7 @@ impl SymbolTable { }, None => { return Err( - ParseError2::new_error(&module.source, import.position, "Cannot resolve module") + ParseError::new_error(&module.source, import.position, "Cannot resolve module") ); } } @@ -158,7 +158,7 @@ impl SymbolTable { module.root_id, *definition_id ) { return Err( - ParseError2::new_error(&module.source, definition.position(), "Symbol is multiply defined") + ParseError::new_error(&module.source, definition.position(), "Symbol is multiply defined") .with_postfixed_info(&module.source, previous_position, "Previous definition was here") ) } @@ -176,11 +176,11 @@ impl SymbolTable { // Find the module using its name let target_root_id = self.resolve_module(&import.module_name); if target_root_id.is_none() { - return Err(ParseError2::new_error(&module.source, import.position, "Could not resolve module")); + return Err(ParseError::new_error(&module.source, import.position, "Could not resolve module")); } let target_root_id = target_root_id.unwrap(); if target_root_id == module.root_id { - return Err(ParseError2::new_error(&module.source, import.position, "Illegal import of self")); + return Err(ParseError::new_error(&module.source, import.position, "Illegal import of self")); } // Add the target module under its alias @@ -189,7 +189,7 @@ impl SymbolTable { target_root_id ) { return Err( - ParseError2::new_error(&module.source, import.position, "Symbol is multiply defined") + ParseError::new_error(&module.source, import.position, "Symbol is multiply defined") .with_postfixed_info(&module.source, previous_position, "Previous definition was here") ); } @@ -198,11 +198,11 @@ impl SymbolTable { // Find the target module using its name let target_root_id = self.resolve_module(&import.module_name); if target_root_id.is_none() { - return Err(ParseError2::new_error(&module.source, import.position, "Could not resolve module of symbol imports")); + return Err(ParseError::new_error(&module.source, import.position, "Could not resolve module of symbol imports")); } let target_root_id = target_root_id.unwrap(); if target_root_id == module.root_id { - return Err(ParseError2::new_error(&module.source, import.position, "Illegal import of self")); + return Err(ParseError::new_error(&module.source, import.position, "Illegal import of self")); } // Determine which symbols to import @@ -216,7 +216,7 @@ impl SymbolTable { target_root_id, *definition_id ) { return Err( - ParseError2::new_error( + ParseError::new_error( &module.source, import.position, &format!("Imported symbol '{}' is already defined", String::from_utf8_lossy(&identifier.value)) ) @@ -267,7 +267,7 @@ impl SymbolTable { if symbol_definition_id.is_none() { return Err( - ParseError2::new_error(&module.source, symbol.position, "Could not resolve symbol") + ParseError::new_error(&module.source, symbol.position, "Could not resolve symbol") ) } let symbol_definition_id = symbol_definition_id.unwrap(); @@ -277,7 +277,7 @@ impl SymbolTable { target_root_id, symbol_definition_id ) { return Err( - ParseError2::new_error(&module.source, symbol.position, "Symbol is multiply defined") + ParseError::new_error(&module.source, symbol.position, "Symbol is multiply defined") .with_postfixed_info(&module.source, previous_position, "Previous definition was here") ) } diff --git a/src/protocol/parser/type_resolver.rs b/src/protocol/parser/type_resolver.rs index 4d6fa9f4447a2ed62720f2db5d3d4319eed02adb..a964b54db36f6d55fc500238aee0b9caf9e73061 100644 --- a/src/protocol/parser/type_resolver.rs +++ b/src/protocol/parser/type_resolver.rs @@ -1291,7 +1291,7 @@ macro_rules! debug_assert_ptrs_distinct { } impl TypeResolvingVisitor { - fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError2> { + fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError> { // Keep inferring until we can no longer make any progress while let Some(next_expr_id) = self.expr_queued.iter().next() { let next_expr_id = *next_expr_id; @@ -1318,7 +1318,7 @@ impl TypeResolvingVisitor { expr_type.parts[0] = InferenceTypePart::Int; } else { let expr = &ctx.heap[*expr_id]; - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, expr.position(), &format!( "Could not fully infer the type of this expression (got '{}')", @@ -1366,7 +1366,7 @@ impl TypeResolvingVisitor { // TODO: Single clean function for function signatures and polyvars. // TODO: Better error message let expr = &ctx.heap[*expr_id]; - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, expr.position(), &format!( "Could not fully infer the type of polymorphic variable {} of this expression (got '{}')", @@ -1422,7 +1422,7 @@ impl TypeResolvingVisitor { Ok(()) } - fn progress_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> Result<(), ParseError2> { + fn progress_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> Result<(), ParseError> { match &ctx.heap[id] { Expression::Assignment(expr) => { let id = expr.this; @@ -1471,7 +1471,7 @@ impl TypeResolvingVisitor { } } - fn progress_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> Result<(), ParseError2> { + fn progress_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> Result<(), ParseError> { use AssignmentOperator as AO; // TODO: Assignable check @@ -1513,7 +1513,7 @@ impl TypeResolvingVisitor { Ok(()) } - fn progress_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError2> { + fn progress_conditional_expr(&mut self, ctx: &mut Ctx, id: ConditionalExpressionId) -> Result<(), ParseError> { // Note: test expression type is already enforced let upcast_id = id.upcast(); let expr = &ctx.heap[id]; @@ -1542,7 +1542,7 @@ impl TypeResolvingVisitor { Ok(()) } - fn progress_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> Result<(), ParseError2> { + fn progress_binary_expr(&mut self, ctx: &mut Ctx, id: BinaryExpressionId) -> Result<(), ParseError> { // Note: our expression type might be fixed by our parent, but we still // need to make sure it matches the type associated with our operation. use BinaryOperator as BO; @@ -1626,7 +1626,7 @@ impl TypeResolvingVisitor { Ok(()) } - fn progress_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> Result<(), ParseError2> { + fn progress_unary_expr(&mut self, ctx: &mut Ctx, id: UnaryExpressionId) -> Result<(), ParseError> { use UnaryOperation as UO; let upcast_id = id.upcast(); @@ -1673,7 +1673,7 @@ impl TypeResolvingVisitor { Ok(()) } - fn progress_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> Result<(), ParseError2> { + fn progress_indexing_expr(&mut self, ctx: &mut Ctx, id: IndexingExpressionId) -> Result<(), ParseError> { let upcast_id = id.upcast(); let expr = &ctx.heap[id]; let subject_id = expr.subject; @@ -1705,7 +1705,7 @@ impl TypeResolvingVisitor { Ok(()) } - fn progress_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> Result<(), ParseError2> { + fn progress_slicing_expr(&mut self, ctx: &mut Ctx, id: SlicingExpressionId) -> Result<(), ParseError> { let upcast_id = id.upcast(); let expr = &ctx.heap[id]; let subject_id = expr.subject; @@ -1743,7 +1743,7 @@ impl TypeResolvingVisitor { Ok(()) } - fn progress_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> Result<(), ParseError2> { + fn progress_select_expr(&mut self, ctx: &mut Ctx, id: SelectExpressionId) -> Result<(), ParseError> { let upcast_id = id.upcast(); debug_log!("Select expr: {}", upcast_id.index); @@ -1801,7 +1801,7 @@ impl TypeResolvingVisitor { let struct_def = if let DefinedTypeVariant::Struct(struct_def) = &type_def.definition { struct_def } else { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, field.identifier.position, &format!( "Can only apply field access to structs, got a subject of type '{}'", @@ -1822,7 +1822,7 @@ impl TypeResolvingVisitor { if field.definition.is_none() { let field_position = field.identifier.position; let ast_struct_def = ctx.heap[type_def.ast_definition].as_struct(); - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, field_position, &format!( "This field does not exist on the struct '{}'", @@ -1841,7 +1841,7 @@ impl TypeResolvingVisitor { return Ok(()) }, Err(()) => { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, field.identifier.position, &format!( "Can only apply field access to structs, got a subject of type '{}'", @@ -1917,7 +1917,7 @@ impl TypeResolvingVisitor { Ok(()) } - fn progress_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> Result<(), ParseError2> { + fn progress_array_expr(&mut self, ctx: &mut Ctx, id: ArrayExpressionId) -> Result<(), ParseError> { let upcast_id = id.upcast(); let expr = &ctx.heap[id]; let expr_elements = expr.elements.clone(); // TODO: @performance @@ -1958,7 +1958,7 @@ impl TypeResolvingVisitor { Ok(()) } - fn progress_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> Result<(), ParseError2> { + fn progress_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> Result<(), ParseError> { let upcast_id = id.upcast(); let expr = &ctx.heap[id]; @@ -2082,7 +2082,7 @@ impl TypeResolvingVisitor { // TODO: @cleanup, see how this can be cleaned up once I implement // polymorphic struct/enum/union literals. These likely follow the same // pattern as here. - fn progress_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> Result<(), ParseError2> { + fn progress_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> Result<(), ParseError> { let upcast_id = id.upcast(); let expr = &ctx.heap[id]; let extra = self.extra_data.get_mut(&upcast_id).unwrap(); @@ -2195,7 +2195,7 @@ impl TypeResolvingVisitor { Ok(()) } - fn progress_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> Result<(), ParseError2> { + fn progress_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> Result<(), ParseError> { let upcast_id = id.upcast(); let var_expr = &ctx.heap[id]; let var_id = var_expr.declaration.unwrap(); @@ -2214,7 +2214,7 @@ impl TypeResolvingVisitor { ) }; if infer_res == DualInferenceResult::Incompatible { let var_decl = &ctx.heap[var_id]; - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, var_decl.position(), &format!( "Conflicting types for this variable, previously assigned the type '{}'", @@ -2268,7 +2268,7 @@ impl TypeResolvingVisitor { let var_decl = &ctx.heap[var_id]; let link_decl = &ctx.heap[linked_id]; - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, var_decl.position(), &format!( "Conflicting types for this variable, assigned the type '{}'", @@ -2311,7 +2311,7 @@ impl TypeResolvingVisitor { /// an array of T) fn apply_forced_constraint( &mut self, ctx: &mut Ctx, expr_id: ExpressionId, template: &[InferenceTypePart] - ) -> Result { + ) -> Result { debug_assert_expr_ids_unique_and_known!(self, expr_id); let expr_type = self.expr_types.get_mut(&expr_id).unwrap(); match InferenceType::infer_subtree_for_single_type(expr_type, 0, template, 0) { @@ -2345,7 +2345,7 @@ impl TypeResolvingVisitor { &mut self, ctx: &Ctx, expr_id: ExpressionId, arg1_id: ExpressionId, arg1_start_idx: usize, arg2_id: ExpressionId, arg2_start_idx: usize - ) -> Result<(bool, bool), ParseError2> { + ) -> Result<(bool, bool), ParseError> { debug_assert_expr_ids_unique_and_known!(self, arg1_id, arg2_id); let arg1_type: *mut _ = self.expr_types.get_mut(&arg1_id).unwrap(); let arg2_type: *mut _ = self.expr_types.get_mut(&arg2_id).unwrap(); @@ -2375,7 +2375,7 @@ impl TypeResolvingVisitor { polymorph_data: &mut ExtraData, polymorph_progress: &mut HashSet, signature_type: *mut InferenceType, signature_start_idx: usize, expression_type: *mut InferenceType, expression_start_idx: usize - ) -> Result<(bool, bool), ParseError2> { + ) -> Result<(bool, bool), ParseError> { // Safety: cannot mutually infer the same types // polymorph_data containers may not be modified debug_assert_ptrs_distinct!(signature_type, expression_type); @@ -2400,7 +2400,7 @@ impl TypeResolvingVisitor { (&*expression_type).display_name(&ctx.heap) ) }; - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, outer_position, "Failed to fully resolve the types of this expression" ).with_postfixed_info( @@ -2503,7 +2503,7 @@ impl TypeResolvingVisitor { &mut self, ctx: &Ctx, expr_id: ExpressionId, arg1_id: ExpressionId, arg2_id: ExpressionId, start_idx: usize - ) -> Result<(bool, bool, bool), ParseError2> { + ) -> Result<(bool, bool, bool), ParseError> { // Safety: all expression IDs are always distinct, and we do not modify // the container debug_assert_expr_ids_unique_and_known!(self, expr_id, arg1_id, arg2_id); @@ -2547,7 +2547,7 @@ impl TypeResolvingVisitor { // a lot more efficiently, methinks (disregarding the allocations here) fn apply_equal_n_constraint( &mut self, ctx: &Ctx, expr_id: ExpressionId, args: &[ExpressionId], - ) -> Result, ParseError2> { + ) -> Result, ParseError> { // Early exit match args.len() { 0 => return Ok(vec!()), // nothing to progress @@ -2609,7 +2609,7 @@ impl TypeResolvingVisitor { /// of subexpressions before they have a chance to call this function. fn insert_initial_expr_inference_type( &mut self, ctx: &mut Ctx, expr_id: ExpressionId - ) -> Result<(), ParseError2> { + ) -> Result<(), ParseError> { use ExpressionParent as EP; use InferenceTypePart as ITP; @@ -2985,14 +2985,14 @@ impl TypeResolvingVisitor { /// "if statement" or a "logical not" always expecting a boolean) fn construct_expr_type_error( &self, ctx: &Ctx, expr_id: ExpressionId, arg_id: ExpressionId - ) -> ParseError2 { + ) -> ParseError { // TODO: Expand and provide more meaningful information for humans let expr = &ctx.heap[expr_id]; let arg_expr = &ctx.heap[arg_id]; let expr_type = self.expr_types.get(&expr_id).unwrap(); let arg_type = self.expr_types.get(&arg_id).unwrap(); - return ParseError2::new_error( + return ParseError::new_error( &ctx.module.source, expr.position(), &format!( "Incompatible types: this expression expected a '{}'", @@ -3010,7 +3010,7 @@ impl TypeResolvingVisitor { fn construct_arg_type_error( &self, ctx: &Ctx, expr_id: ExpressionId, arg1_id: ExpressionId, arg2_id: ExpressionId - ) -> ParseError2 { + ) -> ParseError { let expr = &ctx.heap[expr_id]; let arg1 = &ctx.heap[arg1_id]; let arg2 = &ctx.heap[arg2_id]; @@ -3018,7 +3018,7 @@ impl TypeResolvingVisitor { let arg1_type = self.expr_types.get(&arg1_id).unwrap(); let arg2_type = self.expr_types.get(&arg2_id).unwrap(); - return ParseError2::new_error( + return ParseError::new_error( &ctx.module.source, expr.position(), "Incompatible types: cannot apply this expression" ).with_postfixed_info( @@ -3038,11 +3038,11 @@ impl TypeResolvingVisitor { fn construct_template_type_error( &self, ctx: &Ctx, expr_id: ExpressionId, template: &[InferenceTypePart] - ) -> ParseError2 { + ) -> ParseError { let expr = &ctx.heap[expr_id]; let expr_type = self.expr_types.get(&expr_id).unwrap(); - return ParseError2::new_error( + return ParseError::new_error( &ctx.module.source, expr.position(), &format!( "Incompatible types: got a '{}' but expected a '{}'", @@ -3064,7 +3064,7 @@ impl TypeResolvingVisitor { /// and that an actual error has occurred. fn construct_poly_arg_error( ctx: &Ctx, poly_data: &ExtraData, expr_id: ExpressionId - ) -> ParseError2 { + ) -> ParseError { // Helper function to check for polymorph mismatch between two inference // types. fn has_poly_mismatch<'a>(type_a: &'a InferenceType, type_b: &'a InferenceType) -> Option<(usize, &'a [InferenceTypePart], &'a [InferenceTypePart])> { @@ -3126,11 +3126,11 @@ impl TypeResolvingVisitor { } // Helper function to construct initial error - fn construct_main_error(ctx: &Ctx, poly_var_idx: usize, expr: &Expression) -> ParseError2 { + fn construct_main_error(ctx: &Ctx, poly_var_idx: usize, expr: &Expression) -> ParseError { match expr { Expression::Call(expr) => { let (poly_var, func_name) = get_poly_var_and_func_name(ctx, poly_var_idx, expr); - return ParseError2::new_error( + return ParseError::new_error( &ctx.module.source, expr.position(), &format!( "Conflicting type for polymorphic variable '{}' of '{}'", @@ -3141,7 +3141,7 @@ impl TypeResolvingVisitor { Expression::Literal(expr) => { let lit_struct = expr.value.as_struct(); let (poly_var, struct_name) = get_poly_var_and_type_name(ctx, poly_var_idx, lit_struct.definition.unwrap()); - return ParseError2::new_error( + return ParseError::new_error( &ctx.module.source, expr.position(), &format!( "Conflicting type for polymorphic variable '{}' of instantiation of '{}'", @@ -3152,7 +3152,7 @@ impl TypeResolvingVisitor { Expression::Select(expr) => { let field = expr.field.as_symbolic(); let (poly_var, struct_name) = get_poly_var_and_type_name(ctx, poly_var_idx, field.definition.unwrap()); - return ParseError2::new_error( + return ParseError::new_error( &ctx.module.source, expr.position(), &format!( "Conflicting type for polymorphic variable '{}' while accessing field '{}' of '{}'", diff --git a/src/protocol/parser/type_table.rs b/src/protocol/parser/type_table.rs index 70864808b1ae924ec18d324dcea70e5253bcfea3..d61f25c0d6159963e1cd11de99c21b5b310267d2 100644 --- a/src/protocol/parser/type_table.rs +++ b/src/protocol/parser/type_table.rs @@ -318,7 +318,7 @@ impl TypeTable { } } - pub(crate) fn build_base_types(&mut self, ctx: &mut TypeCtx) -> Result<(), ParseError2> { + pub(crate) fn build_base_types(&mut self, ctx: &mut TypeCtx) -> Result<(), ParseError> { // Make sure we're allowed to cast root_id to index into ctx.modules debug_assert!(self.lookup.is_empty()); debug_assert!(self.iter.top().is_none()); @@ -380,7 +380,7 @@ impl TypeTable { /// This function will resolve just the basic definition of the type, it /// will not handle any of the monomorphized instances of the type. - fn resolve_base_definition<'a>(&'a mut self, ctx: &mut TypeCtx, definition_id: DefinitionId) -> Result<(), ParseError2> { + fn resolve_base_definition<'a>(&'a mut self, ctx: &mut TypeCtx, definition_id: DefinitionId) -> Result<(), ParseError> { // Check if we have already resolved the base definition if self.lookup.contains_key(&definition_id) { return Ok(()); } @@ -415,7 +415,7 @@ impl TypeTable { /// not instantiate any monomorphized instances of polymorphic enum /// definitions. If a subtype has to be resolved first then this function /// will return `false` after calling `ingest_resolve_result`. - fn resolve_base_enum_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result { + fn resolve_base_enum_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result { debug_assert!(ctx.heap[definition_id].is_enum()); debug_assert!(!self.lookup.contains_key(&definition_id), "base enum already resolved"); @@ -452,7 +452,7 @@ impl TypeTable { let tag_pos = first_tag_value.unwrap(); let int_pos = first_int_value.unwrap(); return Err( - ParseError2::new_error( + ParseError::new_error( module_source, definition.position, "Illegal combination of enum integer variant(s) and enum union variant(s)" ) @@ -578,7 +578,7 @@ impl TypeTable { /// Resolves the basic struct definition to an entry in the type table. It /// will not instantiate any monomorphized instances of polymorphic struct /// definitions. - fn resolve_base_struct_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result { + fn resolve_base_struct_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result { debug_assert!(ctx.heap[definition_id].is_struct()); debug_assert!(!self.lookup.contains_key(&definition_id), "base struct already resolved"); @@ -633,7 +633,7 @@ impl TypeTable { /// Resolves the basic function definition to an entry in the type table. It /// will not instantiate any monomorphized instances of polymorphic function /// definitions. - fn resolve_base_function_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result { + fn resolve_base_function_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result { debug_assert!(ctx.heap[definition_id].is_function()); debug_assert!(!self.lookup.contains_key(&definition_id), "base function already resolved"); @@ -705,7 +705,7 @@ impl TypeTable { /// Resolves the basic component definition to an entry in the type table. /// It will not instantiate any monomorphized instancees of polymorphic /// component definitions. - fn resolve_base_component_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result { + fn resolve_base_component_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result { debug_assert!(ctx.heap[definition_id].is_component()); debug_assert!(!self.lookup.contains_key(&definition_id), "base component already resolved"); @@ -769,7 +769,7 @@ impl TypeTable { /// resolving the current type and exit to the outer resolving loop. In the /// latter case the `result` value was `ResolveResult::Unresolved`, implying /// that the type must be resolved first. - fn ingest_resolve_result(&mut self, ctx: &TypeCtx, result: ResolveResult) -> Result { + fn ingest_resolve_result(&mut self, ctx: &TypeCtx, result: ResolveResult) -> Result { match result { ResolveResult::BuiltIn | ResolveResult::PolyArg(_) => Ok(true), ResolveResult::Resolved(_) => Ok(true), @@ -777,7 +777,7 @@ impl TypeTable { if self.iter.contains(root_id, definition_id) { // Cyclic dependency encountered // TODO: Allow this - let mut error = ParseError2::new_error( + let mut error = ParseError::new_error( &ctx.modules[root_id.index as usize].source, ctx.heap[definition_id].position(), "Evaluating this type definition results in a cyclic type" ); @@ -817,7 +817,7 @@ impl TypeTable { /// tree is not yet resolved, then one may receive a (module, definition) /// tuple that does not correspond to the `parser_type_id` passed into this /// function. - fn resolve_base_parser_type(&mut self, ctx: &TypeCtx, poly_vars: &Vec, root_id: RootId, parser_type_id: ParserTypeId) -> Result { + fn resolve_base_parser_type(&mut self, ctx: &TypeCtx, poly_vars: &Vec, root_id: RootId, parser_type_id: ParserTypeId) -> Result { use ParserTypeVariant as PTV; // Prepping iterator @@ -866,7 +866,7 @@ impl TypeTable { // Lookup the definition in the symbol table let (symbol, mut ident_iter) = ctx.symbols.resolve_namespaced_identifier(root_id, &symbolic.identifier); if symbol.is_none() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.modules[root_id.index as usize].source, symbolic.identifier.position, "Could not resolve type" )) @@ -882,14 +882,14 @@ impl TypeTable { return if ident_iter.num_remaining() == 0 { // Could also have polymorphic args, but we // don't care, just throw this error: - Err(ParseError2::new_error( + Err(ParseError::new_error( module_source, symbolic.identifier.position, "Expected a type, got a module name" )) } else if last_ident.is_some() && last_ident.map(|(_, poly_args)| poly_args.is_some()).unwrap() { // Halted at a namespaced because we encountered // polymorphic arguments - Err(ParseError2::new_error( + Err(ParseError::new_error( module_source, symbolic.identifier.position, "Illegal specification of polymorphic arguments to a module name" )) @@ -909,7 +909,7 @@ impl TypeTable { // Namespaced identifier is longer than the type // we found. Return the appropriate message return if definition.is_struct() || definition.is_enum() { - Err(ParseError2::new_error( + Err(ParseError::new_error( module_source, symbolic.identifier.position, &format!( "Unknown type '{}', did you mean to use '{}'?", @@ -918,7 +918,7 @@ impl TypeTable { ) )) } else { - Err(ParseError2::new_error( + Err(ParseError::new_error( module_source, symbolic.identifier.position, "Unknown datatype" )) @@ -927,7 +927,7 @@ impl TypeTable { // Found a match, make sure it is a datatype if !(definition.is_struct() || definition.is_enum()) { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( module_source, symbolic.identifier.position, "Embedded types must be datatypes (structs or enums)" )) @@ -989,7 +989,7 @@ impl TypeTable { &mut self, ctx: &mut TypeCtx, type_definition_id: DefinitionId, poly_args: &mut [PolyVar], root_id: RootId, embedded_type_id: ParserTypeId, - ) -> Result<(), ParseError2> { + ) -> Result<(), ParseError> { use ParserTypeVariant as PTV; self.parser_type_iter.clear(); @@ -1065,7 +1065,7 @@ impl TypeTable { format!("accepts {} polymorphic arguments", defined_type.poly_vars.len()) }; - return Err(ParseError2::new_error( + return Err(ParseError::new_error( module_source, symbolic.identifier.position, &format!( "The type '{}' {}, but {} polymorphic arguments were provided", @@ -1090,14 +1090,14 @@ impl TypeTable { /// unique names fn check_identifier_collision &Identifier>( &self, ctx: &TypeCtx, root_id: RootId, items: &[T], getter: F, item_name: &'static str - ) -> Result<(), ParseError2> { + ) -> Result<(), ParseError> { for (item_idx, item) in items.iter().enumerate() { let item_ident = getter(item); for other_item in &items[0..item_idx] { let other_item_ident = getter(other_item); if item_ident == other_item_ident { let module_source = &ctx.modules[root_id.index as usize].source; - return Err(ParseError2::new_error( + return Err(ParseError::new_error( module_source, item_ident.position, &format!("This {} is defined more than once", item_name) ).with_postfixed_info( module_source, other_item_ident.position, &format!("The other {} is defined here", item_name) @@ -1114,14 +1114,14 @@ impl TypeTable { /// any symbols defined at the module scope. fn check_poly_args_collision( &self, ctx: &TypeCtx, root_id: RootId, poly_args: &[Identifier] - ) -> Result<(), ParseError2> { + ) -> Result<(), ParseError> { // Make sure polymorphic arguments are unique and none of the // identifiers conflict with any imported scopes for (arg_idx, poly_arg) in poly_args.iter().enumerate() { for other_poly_arg in &poly_args[..arg_idx] { if poly_arg == other_poly_arg { let module_source = &ctx.modules[root_id.index as usize].source; - return Err(ParseError2::new_error( + return Err(ParseError::new_error( module_source, poly_arg.position, "This polymorphic argument is defined more than once" ).with_postfixed_info( @@ -1136,7 +1136,7 @@ impl TypeTable { if let Some(symbol) = ctx.symbols.resolve_symbol(root_id, &poly_arg.value) { // We have a conflict let module_source = &ctx.modules[root_id.index as usize].source; - return Err(ParseError2::new_error( + return Err(ParseError::new_error( module_source, poly_arg.position, "This polymorphic argument conflicts with another symbol" ).with_postfixed_info( diff --git a/src/protocol/parser/utils.rs b/src/protocol/parser/utils.rs index 4dc068027128cdf242a7f28e46714adcb0b94dae..8621e7adcc374abaa948e58dd96cc7cc65c1c649 100644 --- a/src/protocol/parser/utils.rs +++ b/src/protocol/parser/utils.rs @@ -20,17 +20,17 @@ impl<'t, 'i> FindTypeResult<'t, 'i> { /// Utility function to transform the `FindTypeResult` into a `Result` where /// `Ok` contains the resolved type, and `Err` contains a `ParseError` which /// can be readily returned. This is the most common use. - pub(crate) fn as_parse_error(self, module_source: &InputSource) -> Result<(&'t DefinedType, NamespacedIdentifierIter<'i>), ParseError2> { + pub(crate) fn as_parse_error(self, module_source: &InputSource) -> Result<(&'t DefinedType, NamespacedIdentifierIter<'i>), ParseError> { match self { FindTypeResult::Found(defined_type) => Ok(defined_type), FindTypeResult::SymbolNotFound{ident_pos} => { - Err(ParseError2::new_error( + Err(ParseError::new_error( module_source, ident_pos, "Could not resolve this identifier to a symbol" )) }, FindTypeResult::SymbolPartial{ident_pos, ident_iter} => { - Err(ParseError2::new_error( + Err(ParseError::new_error( module_source, ident_pos, &format!( "Could not fully resolve this identifier to a symbol, was only able to match '{}'", @@ -39,7 +39,7 @@ impl<'t, 'i> FindTypeResult<'t, 'i> { )) }, FindTypeResult::SymbolNamespace{ident_pos, symbol_pos} => { - Err(ParseError2::new_error( + Err(ParseError::new_error( module_source, ident_pos, "This identifier was resolved to a namespace instead of a type" ).with_postfixed_info( @@ -98,7 +98,7 @@ pub(crate) enum MatchPolymorphResult<'t> { } impl<'t> MatchPolymorphResult<'t> { - pub(crate) fn as_parse_error(self, heap: &Heap, module_source: &InputSource) -> Result { + pub(crate) fn as_parse_error(self, heap: &Heap, module_source: &InputSource) -> Result { match self { MatchPolymorphResult::Matching => Ok(0), MatchPolymorphResult::InferAll(count) => { @@ -113,7 +113,7 @@ impl<'t> MatchPolymorphResult<'t> { "arguments" }; - return Err(ParseError2::new_error( + return Err(ParseError::new_error( module_source, ident_position, &format!( "expected {} polymorphic {} (or none, to infer them) for the type {}, but {} were specified", @@ -125,7 +125,7 @@ impl<'t> MatchPolymorphResult<'t> { }, MatchPolymorphResult::NoneExpected{defined_type, ident_position, ..} => { let type_identifier = heap[defined_type.ast_definition].identifier(); - return Err(ParseError2::new_error( + return Err(ParseError::new_error( module_source, ident_position, &format!( "the type {} is not polymorphic", diff --git a/src/protocol/parser/visitor.rs b/src/protocol/parser/visitor.rs index 6c829516881768ccaec218b1cba7ecc1a20008bf..70e3267c52f0af14f06c7d0de954a24c6d231655 100644 --- a/src/protocol/parser/visitor.rs +++ b/src/protocol/parser/visitor.rs @@ -3,7 +3,7 @@ use crate::protocol::inputsource::*; use crate::protocol::parser::{symbol_table::*, type_table::*, LexedModule}; type Unit = (); -pub(crate) type VisitorResult = Result; +pub(crate) type VisitorResult = Result; /// Globally configured vector capacity for statement buffers in visitor /// implementations diff --git a/src/protocol/parser/visitor_linker.rs b/src/protocol/parser/visitor_linker.rs index 841fea37e5825438c1601f9501ad24e6c91cda68..a28d42f6c9b26a4e15417b86dd3526c1070ad76c 100644 --- a/src/protocol/parser/visitor_linker.rs +++ b/src/protocol/parser/visitor_linker.rs @@ -369,13 +369,13 @@ impl Visitor2 for ValidityAndLinkerVisitor { // Nested synchronous statement let old_sync = &ctx.heap[self.in_sync.unwrap()]; return Err( - ParseError2::new_error(&ctx.module.source, cur_sync_position, "Illegal nested synchronous statement") + ParseError::new_error(&ctx.module.source, cur_sync_position, "Illegal nested synchronous statement") .with_postfixed_info(&ctx.module.source, old_sync.position, "It is nested in this synchronous statement") ); } if !self.def_type.is_primitive() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, cur_sync_position, "Synchronous statements may only be used in primitive components" )); @@ -406,7 +406,7 @@ impl Visitor2 for ValidityAndLinkerVisitor { let stmt = &ctx.heap[id]; if !self.def_type.is_function() { return Err( - ParseError2::new_error(&ctx.module.source, stmt.position, "Return statements may only appear in function bodies") + ParseError::new_error(&ctx.module.source, stmt.position, "Return statements may only appear in function bodies") ); } } else { @@ -429,7 +429,7 @@ impl Visitor2 for ValidityAndLinkerVisitor { // within components. Such a marker will cascade through any // functions that then call an asserting function return Err( - ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal assert statement in a function") + ParseError::new_error(&ctx.module.source, stmt.position, "Illegal assert statement in a function") ); } @@ -437,7 +437,7 @@ impl Visitor2 for ValidityAndLinkerVisitor { // synchronous statement if self.in_sync.is_none() { return Err( - ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal assert statement outside of a synchronous block") + ParseError::new_error(&ctx.module.source, stmt.position, "Illegal assert statement outside of a synchronous block") ); } } else { @@ -469,7 +469,7 @@ impl Visitor2 for ValidityAndLinkerVisitor { let goto_stmt = &ctx.heap[id]; let sync_stmt = &ctx.heap[self.in_sync.unwrap()]; return Err( - ParseError2::new_error(&ctx.module.source, goto_stmt.position, "Goto may not escape the surrounding synchronous block") + ParseError::new_error(&ctx.module.source, goto_stmt.position, "Goto may not escape the surrounding synchronous block") .with_postfixed_info(&ctx.module.source, target.position, "This is the target of the goto statement") .with_postfixed_info(&ctx.module.source, sync_stmt.position, "Which will jump past this statement") ); @@ -488,7 +488,7 @@ impl Visitor2 for ValidityAndLinkerVisitor { if !self.def_type.is_composite() { let new_stmt = &ctx.heap[id]; return Err( - ParseError2::new_error(&ctx.module.source, new_stmt.position, "Instantiating components may only be done in composite components") + ParseError::new_error(&ctx.module.source, new_stmt.position, "Instantiating components may only be done in composite components") ); } @@ -499,7 +499,7 @@ impl Visitor2 for ValidityAndLinkerVisitor { // We're fine } else { return Err( - ParseError2::new_error(&ctx.module.source, call_expr.position, "Must instantiate a component") + ParseError::new_error(&ctx.module.source, call_expr.position, "Must instantiate a component") ); } } else { @@ -738,7 +738,7 @@ impl Visitor2 for ValidityAndLinkerVisitor { // Check if not found if field.field_idx == FIELD_NOT_FOUND_SENTINEL { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, field.identifier.position, &format!( "This field does not exist on the struct '{}'", @@ -749,7 +749,7 @@ impl Visitor2 for ValidityAndLinkerVisitor { // Check if specified more than once if specified[field.field_idx] { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, field.identifier.position, "This field is specified more than once" )); @@ -769,7 +769,7 @@ impl Visitor2 for ValidityAndLinkerVisitor { } } - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, literal.identifier.position, &format!("Not all fields are specified, [{}] are missing", not_specified) )); @@ -815,13 +815,13 @@ impl Visitor2 for ValidityAndLinkerVisitor { }, Method::Fires => { if !self.def_type.is_primitive() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, call_expr.position, "A call to 'fires' may only occur in primitive component definitions" )); } if self.in_sync.is_none() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, call_expr.position, "A call to 'fires' may only occur inside synchronous blocks" )); @@ -830,13 +830,13 @@ impl Visitor2 for ValidityAndLinkerVisitor { }, Method::Get => { if !self.def_type.is_primitive() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, call_expr.position, "A call to 'get' may only occur in primitive component definitions" )); } if self.in_sync.is_none() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, call_expr.position, "A call to 'get' may only occur inside synchronous blocks" )); @@ -845,13 +845,13 @@ impl Visitor2 for ValidityAndLinkerVisitor { }, Method::Put => { if !self.def_type.is_primitive() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, call_expr.position, "A call to 'put' may only occur in primitive component definitions" )); } if self.in_sync.is_none() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, call_expr.position, "A call to 'put' may only occur inside synchronous blocks" )); @@ -891,7 +891,7 @@ impl Visitor2 for ValidityAndLinkerVisitor { self.visit_call_poly_args(ctx, id)?; let call_expr = &mut ctx.heap[id]; if num_expr_args != num_definition_args { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, call_expr.position, &format!( "This call expects {} arguments, but {} were provided", @@ -1079,7 +1079,7 @@ impl ValidityAndLinkerVisitor { // Type refers to a polymorphic variable. // TODO: @hkt Maybe allow higher-kinded types? if symbolic.identifier.get_poly_args().is_some() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, symbolic.identifier.position, "Polymorphic arguments to a polymorphic variable (higher-kinded types) are not allowed (yet)" )); @@ -1100,7 +1100,7 @@ impl ValidityAndLinkerVisitor { // TODO: @function_ptrs: Allow function pointers at some // point in the future if found_type.definition.type_class().is_proc_type() { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, symbolic.identifier.position, &format!( "This identifier points to a {} type, expected a datatype", @@ -1166,7 +1166,7 @@ impl ValidityAndLinkerVisitor { /// Adds a local variable to the current scope. It will also annotate the /// `Local` in the AST with its relative position in the block. - fn checked_local_add(&mut self, ctx: &mut Ctx, relative_pos: u32, id: LocalId) -> Result<(), ParseError2> { + fn checked_local_add(&mut self, ctx: &mut Ctx, relative_pos: u32, id: LocalId) -> Result<(), ParseError> { debug_assert!(self.cur_scope.is_some()); // Make sure we do not conflict with any global symbols @@ -1174,7 +1174,7 @@ impl ValidityAndLinkerVisitor { let ident = &ctx.heap[id].identifier; if let Some(symbol) = ctx.symbols.resolve_symbol(ctx.module.root_id, &ident.value) { return Err( - ParseError2::new_error(&ctx.module.source, ident.position, "Local variable declaration conflicts with symbol") + ParseError::new_error(&ctx.module.source, ident.position, "Local variable declaration conflicts with symbol") .with_postfixed_info(&ctx.module.source, symbol.position, "Conflicting symbol is found here") ); } @@ -1202,7 +1202,7 @@ impl ValidityAndLinkerVisitor { local.identifier == other_local.identifier { // Collision within this scope return Err( - ParseError2::new_error(&ctx.module.source, local.position, "Local variable name conflicts with another variable") + ParseError::new_error(&ctx.module.source, local.position, "Local variable name conflicts with another variable") .with_postfixed_info(&ctx.module.source, other_local.position, "Previous variable is found here") ); } @@ -1217,7 +1217,7 @@ impl ValidityAndLinkerVisitor { let parameter = &ctx.heap[*parameter_id]; if local.identifier == parameter.identifier { return Err( - ParseError2::new_error(&ctx.module.source, local.position, "Local variable name conflicts with parameter") + ParseError::new_error(&ctx.module.source, local.position, "Local variable name conflicts with parameter") .with_postfixed_info(&ctx.module.source, parameter.position, "Parameter definition is found here") ); } @@ -1239,7 +1239,7 @@ impl ValidityAndLinkerVisitor { /// Finds a variable in the visitor's scope that must appear before the /// specified relative position within that block. - fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &NamespacedIdentifier) -> Result { + fn find_variable(&self, ctx: &Ctx, mut relative_pos: u32, identifier: &NamespacedIdentifier) -> Result { debug_assert!(self.cur_scope.is_some()); debug_assert!(identifier.parts.len() == 1, "implement namespaced seeking of target associated with identifier"); @@ -1278,7 +1278,7 @@ impl ValidityAndLinkerVisitor { } // Variable could not be found - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, identifier.position, "This variable is not declared" )); } else { @@ -1289,7 +1289,7 @@ impl ValidityAndLinkerVisitor { /// Adds a particular label to the current scope. Will return an error if /// there is another label with the same name visible in the current scope. - fn checked_label_add(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> Result<(), ParseError2> { + fn checked_label_add(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> Result<(), ParseError> { debug_assert!(self.cur_scope.is_some()); // Make sure label is not defined within the current scope or any of the @@ -1305,7 +1305,7 @@ impl ValidityAndLinkerVisitor { if other_label.label == label.label { // Collision return Err( - ParseError2::new_error(&ctx.module.source, label.position, "Label name conflicts with another label") + ParseError::new_error(&ctx.module.source, label.position, "Label name conflicts with another label") .with_postfixed_info(&ctx.module.source, other_label.position, "Other label is found here") ); } @@ -1328,7 +1328,7 @@ impl ValidityAndLinkerVisitor { /// Finds a particular labeled statement by its identifier. Once found it /// will make sure that the target label does not skip over any variable /// declarations within the scope in which the label was found. - fn find_label(&self, ctx: &Ctx, identifier: &Identifier) -> Result { + fn find_label(&self, ctx: &Ctx, identifier: &Identifier) -> Result { debug_assert!(self.cur_scope.is_some()); let mut scope = self.cur_scope.as_ref().unwrap(); @@ -1348,7 +1348,7 @@ impl ValidityAndLinkerVisitor { let local = &ctx.heap[*local_id]; if local.relative_pos_in_block > relative_scope_pos && local.relative_pos_in_block < label.relative_pos_in_block { return Err( - ParseError2::new_error(&ctx.module.source, identifier.position, "This target label skips over a variable declaration") + ParseError::new_error(&ctx.module.source, identifier.position, "This target label skips over a variable declaration") .with_postfixed_info(&ctx.module.source, label.position, "Because it jumps to this label") .with_postfixed_info(&ctx.module.source, local.position, "Which skips over this variable") ); @@ -1361,7 +1361,7 @@ impl ValidityAndLinkerVisitor { debug_assert!(block.parent_scope.is_some(), "block scope does not have a parent"); scope = block.parent_scope.as_ref().unwrap(); if !scope.is_block() { - return Err(ParseError2::new_error(&ctx.module.source, identifier.position, "Could not find this label")); + return Err(ParseError::new_error(&ctx.module.source, identifier.position, "Could not find this label")); } } @@ -1374,14 +1374,14 @@ impl ValidityAndLinkerVisitor { fn find_symbol_of_type<'a>( &self, source: &InputSource, root_id: RootId, symbols: &SymbolTable, types: &'a TypeTable, identifier: &NamespacedIdentifier, expected_type_class: TypeClass - ) -> Result<&'a DefinedType, ParseError2> { + ) -> Result<&'a DefinedType, ParseError> { // Find symbol associated with identifier let (find_result, _) = find_type_definition(symbols, types, root_id, identifier) .as_parse_error(source)?; let definition_type_class = find_result.definition.type_class(); if expected_type_class != definition_type_class { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( source, identifier.position, &format!( "Expected to find a {}, this symbol points to a {}", @@ -1421,7 +1421,7 @@ impl ValidityAndLinkerVisitor { /// ID will be returned, otherwise a parsing error is constructed. /// The provided input position should be the position of the break/continue /// statement. - fn resolve_break_or_continue_target(&self, ctx: &Ctx, position: InputPosition, label: &Option) -> Result { + fn resolve_break_or_continue_target(&self, ctx: &Ctx, position: InputPosition, label: &Option) -> Result { let target = match label { Some(label) => { let target_id = self.find_label(ctx, label)?; @@ -1432,14 +1432,14 @@ impl ValidityAndLinkerVisitor { // Even though we have a target while statement, the break might not be // present underneath this particular labeled while statement if !self.has_parent_while_scope(ctx, target_stmt.this) { - ParseError2::new_error(&ctx.module.source, label.position, "Break statement is not nested under the target label's while statement") + ParseError::new_error(&ctx.module.source, label.position, "Break statement is not nested under the target label's while statement") .with_postfixed_info(&ctx.module.source, target.position, "The targeted label is found here"); } target_stmt.this } else { return Err( - ParseError2::new_error(&ctx.module.source, label.position, "Incorrect break target label, it must target a while loop") + ParseError::new_error(&ctx.module.source, label.position, "Incorrect break target label, it must target a while loop") .with_postfixed_info(&ctx.module.source, target.position, "The targeted label is found here") ); } @@ -1449,7 +1449,7 @@ impl ValidityAndLinkerVisitor { // nested within that while statement if self.in_while.is_none() { return Err( - ParseError2::new_error(&ctx.module.source, position, "Break statement is not nested under a while loop") + ParseError::new_error(&ctx.module.source, position, "Break statement is not nested under a while loop") ); } @@ -1467,7 +1467,7 @@ impl ValidityAndLinkerVisitor { debug_assert!(self.in_sync.is_some()); let sync_stmt = &ctx.heap[self.in_sync.unwrap()]; return Err( - ParseError2::new_error(&ctx.module.source, position, "Break may not escape the surrounding synchronous block") + ParseError::new_error(&ctx.module.source, position, "Break may not escape the surrounding synchronous block") .with_postfixed_info(&ctx.module.source, target_while.position, "The break escapes out of this loop") .with_postfixed_info(&ctx.module.source, sync_stmt.position, "And would therefore escape this synchronous block") ); @@ -1553,7 +1553,7 @@ impl ValidityAndLinkerVisitor { self.parser_type_buffer.truncate(old_num_types); Ok(()) } else { - return Err(ParseError2::new_error( + return Err(ParseError::new_error( &ctx.module.source, call_expr.position, &format!( "Expected {} polymorphic arguments (or none, to infer them), but {} were specified", diff --git a/src/protocol/tests/utils.rs b/src/protocol/tests/utils.rs index e375b6abc0f348460a6966c94fd1a7cf152d355a..f5aaff9b5281820d684fff34c06aab35d63ddea9 100644 --- a/src/protocol/tests/utils.rs +++ b/src/protocol/tests/utils.rs @@ -551,11 +551,11 @@ impl<'a> ExpressionTester<'a> { pub(crate) struct AstErrTester { test_name: String, - error: ParseError2, + error: ParseError, } impl AstErrTester { - fn new(test_name: String, error: ParseError2) -> Self { + fn new(test_name: String, error: ParseError) -> Self { Self{ test_name, error } } @@ -572,7 +572,7 @@ impl AstErrTester { pub(crate) struct ErrorTester<'a> { test_name: &'a str, - error: &'a ParseError2, + error: &'a ParseError, } impl<'a> ErrorTester<'a> {