rhai/src/error.rs

285 lines
11 KiB
Rust
Raw Normal View History

2020-03-08 12:54:02 +01:00
//! Module containing error definitions for the parsing process.
use crate::result::EvalAltResult;
use crate::token::Position;
2020-03-18 15:03:50 +01:00
2020-06-26 04:39:18 +02:00
use crate::stdlib::{
boxed::Box,
error::Error,
fmt,
string::{String, ToString},
};
2020-03-04 15:00:01 +01:00
/// [INTERNALS] Error encountered when tokenizing the script text.
/// Exported under the `internals` feature only.
///
/// ## WARNING
///
/// This type is volatile and may change.
#[derive(Debug, Eq, PartialEq, Clone, Hash)]
2020-06-25 05:07:46 +02:00
#[non_exhaustive]
2020-03-04 15:00:01 +01:00
pub enum LexError {
2020-07-05 09:23:51 +02:00
/// An unexpected symbol is encountered when tokenizing the script text.
UnexpectedInput(String),
2020-03-04 15:00:01 +01:00
/// A string literal is not terminated before a new-line or EOF.
UnterminatedString,
2020-06-14 08:25:47 +02:00
/// An identifier is in an invalid format.
StringTooLong(usize),
2020-03-04 15:00:01 +01:00
/// An string/character/numeric escape sequence is in an invalid format.
MalformedEscapeSequence(String),
/// An numeric literal is in an invalid format.
MalformedNumber(String),
/// An character literal is in an invalid format.
MalformedChar(String),
2020-03-16 05:38:01 +01:00
/// An identifier is in an invalid format.
MalformedIdentifier(String),
2020-06-14 10:56:36 +02:00
/// Bad symbol encountered when tokenizing the script text.
ImproperSymbol(String),
2020-03-04 15:00:01 +01:00
}
2020-03-14 16:39:45 +01:00
impl Error for LexError {}
2020-03-04 15:00:01 +01:00
impl fmt::Display for LexError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
2020-07-05 09:23:51 +02:00
Self::UnexpectedInput(s) => write!(f, "Unexpected '{}'", s),
2020-03-04 15:00:01 +01:00
Self::MalformedEscapeSequence(s) => write!(f, "Invalid escape sequence: '{}'", s),
Self::MalformedNumber(s) => write!(f, "Invalid number: '{}'", s),
Self::MalformedChar(s) => write!(f, "Invalid character: '{}'", s),
2020-04-03 13:42:01 +02:00
Self::MalformedIdentifier(s) => write!(f, "Variable name is not proper: '{}'", s),
2020-03-14 16:39:45 +01:00
Self::UnterminatedString => write!(f, "Open string is not terminated"),
2020-06-14 08:25:47 +02:00
Self::StringTooLong(max) => write!(
f,
"Length of string literal exceeds the maximum limit ({})",
max
),
2020-07-02 15:46:08 +02:00
Self::ImproperSymbol(s) => f.write_str(s),
2020-03-04 15:00:01 +01:00
}
}
}
2020-06-14 10:56:36 +02:00
impl LexError {
/// Convert a `LexError` into a `ParseError`.
pub fn into_err(&self, pos: Position) -> ParseError {
ParseError(Box::new(self.into()), pos)
}
}
2020-03-04 15:00:01 +01:00
/// Type of error encountered when parsing a script.
2020-04-10 06:16:39 +02:00
///
/// Some errors never appear when certain features are turned on.
/// They still exist so that the application can turn features on and off without going through
/// massive code changes to remove/add back enum variants in match statements.
#[derive(Debug, Eq, PartialEq, Clone, Hash)]
2020-06-25 05:07:46 +02:00
#[non_exhaustive]
2020-03-04 15:00:01 +01:00
pub enum ParseErrorType {
/// Error in the script text. Wrapped value is the error message.
BadInput(String),
/// The script ends prematurely.
UnexpectedEOF,
2020-03-04 15:00:01 +01:00
/// An unknown operator is encountered. Wrapped value is the operator.
UnknownOperator(String),
2020-04-03 13:42:01 +02:00
/// Expecting a particular token but not finding one. Wrapped values are the token and description.
MissingToken(String, String),
2020-04-03 13:42:01 +02:00
/// An expression in function call arguments `()` has syntax error. Wrapped value is the error description (if any).
2020-03-09 03:41:17 +01:00
MalformedCallExpr(String),
2020-04-03 13:42:01 +02:00
/// An expression in indexing brackets `[]` has syntax error. Wrapped value is the error description (if any).
///
2020-04-10 06:16:39 +02:00
/// Never appears under the `no_index` feature.
2020-03-09 03:41:17 +01:00
MalformedIndexExpr(String),
2020-04-06 11:47:34 +02:00
/// An expression in an `in` expression has syntax error. Wrapped value is the error description (if any).
2020-04-10 06:16:39 +02:00
///
/// Never appears under the `no_object` and `no_index` features combination.
2020-04-06 11:47:34 +02:00
MalformedInExpr(String),
2020-04-03 13:42:01 +02:00
/// A map definition has duplicated property names. Wrapped value is the property name.
///
2020-04-10 06:16:39 +02:00
/// Never appears under the `no_object` feature.
2020-03-29 17:53:35 +02:00
DuplicatedProperty(String),
2020-04-03 13:42:01 +02:00
/// Invalid expression assigned to constant. Wrapped value is the name of the constant.
2020-03-13 11:12:41 +01:00
ForbiddenConstantExpr(String),
/// Missing a property name for custom types and maps.
2020-04-10 06:16:39 +02:00
///
/// Never appears under the `no_object` feature.
2020-03-29 17:53:35 +02:00
PropertyExpected,
2020-03-16 05:38:01 +01:00
/// Missing a variable name after the `let`, `const` or `for` keywords.
VariableExpected,
/// An identifier is a reserved keyword.
Reserved(String),
2020-04-03 13:42:01 +02:00
/// Missing an expression. Wrapped value is the expression type.
ExprExpected(String),
2020-03-04 15:00:01 +01:00
/// Defining a function `fn` in an appropriate place (e.g. inside another function).
2020-04-03 13:42:01 +02:00
///
2020-04-10 06:16:39 +02:00
/// Never appears under the `no_function` feature.
2020-03-04 15:00:01 +01:00
WrongFnDefinition,
/// Missing a function name after the `fn` keyword.
2020-04-03 13:42:01 +02:00
///
2020-04-10 06:16:39 +02:00
/// Never appears under the `no_function` feature.
2020-03-04 15:00:01 +01:00
FnMissingName,
/// A function definition is missing the parameters list. Wrapped value is the function name.
2020-04-03 13:42:01 +02:00
///
2020-04-10 06:16:39 +02:00
/// Never appears under the `no_function` feature.
2020-03-04 15:00:01 +01:00
FnMissingParams(String),
/// A function definition has duplicated parameters. Wrapped values are the function name and parameter name.
2020-04-03 13:42:01 +02:00
///
2020-04-10 06:16:39 +02:00
/// Never appears under the `no_function` feature.
FnDuplicatedParam(String, String),
2020-03-17 10:33:37 +01:00
/// A function definition is missing the body. Wrapped value is the function name.
2020-04-03 13:42:01 +02:00
///
2020-04-10 06:16:39 +02:00
/// Never appears under the `no_function` feature.
2020-03-17 10:33:37 +01:00
FnMissingBody(String),
2020-05-08 10:49:24 +02:00
/// An export statement has duplicated names.
///
/// Never appears under the `no_module` feature.
DuplicatedExport(String),
/// Export statement not at global level.
///
/// Never appears under the `no_module` feature.
WrongExport,
/// Assignment to a copy of a value.
AssignmentToCopy,
2020-06-14 08:25:47 +02:00
/// Assignment to an a constant variable. Wrapped value is the constant variable name.
2020-03-13 11:12:41 +01:00
AssignmentToConstant(String),
/// Expression exceeding the maximum levels of complexity.
///
/// Never appears under the `unchecked` feature.
ExprTooDeep,
2020-06-14 08:25:47 +02:00
/// Literal exceeding the maximum size. Wrapped values are the data type name and the maximum size.
///
/// Never appears under the `unchecked` feature.
LiteralTooLarge(String, usize),
2020-03-17 10:33:37 +01:00
/// Break statement not inside a loop.
LoopBreak,
2020-03-04 15:00:01 +01:00
}
2020-03-24 09:46:47 +01:00
impl ParseErrorType {
2020-03-25 04:27:09 +01:00
/// Make a `ParseError` using the current type and position.
pub(crate) fn into_err(self, pos: Position) -> ParseError {
ParseError(Box::new(self), pos)
2020-03-24 09:46:47 +01:00
}
2020-03-04 15:00:01 +01:00
2020-03-14 16:39:45 +01:00
pub(crate) fn desc(&self) -> &str {
match self {
Self::BadInput(p) => p,
Self::UnexpectedEOF => "Script is incomplete",
Self::UnknownOperator(_) => "Unknown operator",
Self::MissingToken(_, _) => "Expecting a certain token that is missing",
Self::MalformedCallExpr(_) => "Invalid expression in function call arguments",
Self::MalformedIndexExpr(_) => "Invalid index in indexing expression",
Self::MalformedInExpr(_) => "Invalid 'in' expression",
Self::DuplicatedProperty(_) => "Duplicated property in object map literal",
Self::ForbiddenConstantExpr(_) => "Expecting a constant",
Self::PropertyExpected => "Expecting name of a property",
Self::VariableExpected => "Expecting name of a variable",
Self::Reserved(_) => "Invalid use of reserved keyword",
Self::ExprExpected(_) => "Expecting an expression",
Self::FnMissingName => "Expecting name in function declaration",
Self::FnMissingParams(_) => "Expecting parameters in function declaration",
Self::FnDuplicatedParam(_,_) => "Duplicated parameters in function declaration",
Self::FnMissingBody(_) => "Expecting body statement block for function declaration",
Self::WrongFnDefinition => "Function definitions must be at global level and cannot be inside a block or another function",
Self::DuplicatedExport(_) => "Duplicated variable/function in export statement",
Self::WrongExport => "Export statement can only appear at global level",
Self::AssignmentToCopy => "Only a copy of the value is change with this assignment",
Self::AssignmentToConstant(_) => "Cannot assign to a constant value",
Self::ExprTooDeep => "Expression exceeds maximum complexity",
2020-06-14 08:25:47 +02:00
Self::LiteralTooLarge(_, _) => "Literal exceeds maximum limit",
Self::LoopBreak => "Break statement should only be used inside a loop"
2020-03-04 15:00:01 +01:00
}
}
}
impl fmt::Display for ParseErrorType {
2020-06-13 11:03:49 +02:00
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::BadInput(s) | ParseErrorType::MalformedCallExpr(s) => {
2020-07-02 15:46:08 +02:00
f.write_str(if s.is_empty() { self.desc() } else { s })
2020-03-09 03:41:17 +01:00
}
Self::ForbiddenConstantExpr(s) => {
write!(f, "Expecting a constant to assign to '{}'", s)
2020-03-13 11:12:41 +01:00
}
Self::UnknownOperator(s) => write!(f, "{}: '{}'", self.desc(), s),
2020-03-16 05:38:01 +01:00
2020-07-02 15:46:08 +02:00
Self::MalformedIndexExpr(s) => f.write_str(if s.is_empty() { self.desc() } else { s }),
2020-03-16 05:38:01 +01:00
2020-07-02 15:46:08 +02:00
Self::MalformedInExpr(s) => f.write_str(if s.is_empty() { self.desc() } else { s }),
2020-04-06 11:47:34 +02:00
Self::DuplicatedProperty(s) => {
write!(f, "Duplicated property '{}' for object map literal", s)
2020-03-29 17:53:35 +02:00
}
Self::ExprExpected(s) => write!(f, "Expecting {} expression", s),
Self::FnMissingParams(s) => write!(f, "Expecting parameters for function '{}'", s),
2020-03-16 05:38:01 +01:00
2020-07-19 11:14:55 +02:00
Self::FnMissingBody(s) if s.is_empty() => {
f.write_str("Expecting body statement block for anonymous function")
}
Self::FnMissingBody(s) => {
write!(f, "Expecting body statement block for function '{}'", s)
2020-03-17 10:33:37 +01:00
}
Self::FnDuplicatedParam(s, arg) => {
write!(f, "Duplicated parameter '{}' for function '{}'", arg, s)
}
Self::DuplicatedExport(s) => write!(
2020-05-08 10:49:24 +02:00
f,
"Duplicated variable/function '{}' in export statement",
s
),
2020-05-08 10:49:24 +02:00
Self::MissingToken(token, s) => write!(f, "Expecting '{}' {}", token, s),
2020-03-16 16:51:32 +01:00
2020-07-02 15:46:08 +02:00
Self::AssignmentToConstant(s) if s.is_empty() => f.write_str(self.desc()),
Self::AssignmentToConstant(s) => write!(f, "Cannot assign to constant '{}'", s),
2020-06-14 08:25:47 +02:00
Self::LiteralTooLarge(typ, max) => {
write!(f, "{} exceeds the maximum limit ({})", typ, max)
}
Self::Reserved(s) => write!(f, "'{}' is a reserved keyword", s),
2020-07-02 15:46:08 +02:00
_ => f.write_str(self.desc()),
2020-03-04 15:00:01 +01:00
}
}
}
2020-06-14 10:56:36 +02:00
impl From<&LexError> for ParseErrorType {
fn from(err: &LexError) -> Self {
match err {
LexError::StringTooLong(max) => {
Self::LiteralTooLarge("Length of string literal".to_string(), *max)
}
_ => Self::BadInput(err.to_string()),
}
}
}
/// Error when parsing a script.
#[derive(Debug, Eq, PartialEq, Clone, Hash)]
pub struct ParseError(pub Box<ParseErrorType>, pub Position);
2020-03-04 15:00:01 +01:00
impl Error for ParseError {}
impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.0, f)?;
// Do not write any position if None
if !self.1.is_none() {
write!(f, " ({})", self.1)?;
2020-03-04 15:00:01 +01:00
}
Ok(())
}
}
impl From<ParseErrorType> for Box<EvalAltResult> {
fn from(err: ParseErrorType) -> Self {
Box::new(EvalAltResult::ErrorParsing(err, Position::none()))
}
}
impl From<ParseError> for Box<EvalAltResult> {
fn from(err: ParseError) -> Self {
Box::new(EvalAltResult::ErrorParsing(*err.0, err.1))
2020-03-04 15:00:01 +01:00
}
}