1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
use lualexer::{Token, LexerErrorType}; /// This enum represents the various errors that may happen while parsing tokens /// into an AST (abstract syntax tree). #[derive(Debug, Clone)] pub enum ParsingError { /// After parsing the last statement of a block (break or return statement), the parser /// expects a token to close the block (e.g. `end`, `until`, `else`). EndOfBlockExpectedAfterLastStatement, /// After parsing the last statement of a chunk (an entire file for example), the parser /// expects no more tokens. EndExpectedAfterLastStatement, /// After parsing a binary operator (`+`, `and`, `or`, `==`, ...), the parser expects an /// expression to form a binary expression. RightExpressionExpected, /// The parser was expecting a token that can start a statement. UnexpectedTokenForStatement, /// When parsing a block, a specific token is expected to close that block. For example, /// when parsing a do statement, the parser expects the keyword `end` to close the inner /// block. For a repeat statement, the parser expects the `until` keyword. TokenExpectedToCloseBlock, /// The parser was expecting the keyword `function` FunctionKeywordExpected, /// The parser was expecting a `(` to begin the parameters definition of a function. OpeningParentheseExpectedForFunction, /// The parser was expecting a `)` to close the parameters definition of a function. ClosingParentheseExpectedForFunction, /// The parser expects a list of identifiers that may end with the variable arguments symbol /// (`...`), separated by commas. The error is return if another token is found. InvalidFunctionParameter, /// The parser was expecting an expression after a unary operator (`#`, `-` or `not`) ExpressionExpectedAfterUnaryOperator, /// After opening a parenthese (as an expression, not a call to a function or /// method), the parser expects an expression. ExpressionExpectedAfterOpeningParenthese, /// When parsing a parenthese expression, the parser expects a closing parenthese after the /// expression. ClosingParentheseExpected, /// When opening a bracket (`[`) to index another value, the parse expects an expression /// followed with a closing bracket (`]`). ClosingBracketExpected, /// When parsing a method call, the parser expects arguments after the method name. ArgumentsExpectedAfterMethod, /// When parsing a table, the parser expects a closing brace to close that table. ClosingBraceExpected, /// The parser expects an expression after the `=` when parsing a field entry in a table /// (`{ key = expect_expression_here }`). ExpressionExpectedForTableEntry, /// The parser expects an expression between brackets when parsing a table entry key /// (`{ [expect_expression_here] = value }`). ExpressionExpectedForTableKey, /// After parsing a table entry key (`[key] = ...`), the parser expects an assign symbol (`=`). AssignSymbolExpectedAfterTableKey, /// When parsing a table key using brackets, the parser expects a closing bracket after the /// expression. ClosingBracketExpectedForTableKey, /// When parsing a while statement, the parser expects an expression after the while keyword. ConditionExpectedForWhileStatement, /// When parsing a while statement, the parser expects the keyword `do` after the condition. DoKeywordExpectedForWhileStatement, /// When parsing a repeat statement, the parser expects an expression after the until keyword. ConditionExpectedForRepeatStatement, /// When parsing an if statement, an expression is expected after the `if` keyword. ConditionExpectedForIfStatement, /// When parsing an if statement, an expression is expected after an `elseif` keyword. ConditionExpectedForElseIfClause, /// When parsing an if statement, a `then` keyword is expected after the condition. ThenKeywordExpectedForIfStatement, /// When parsing an else-if clase, a `then` keyword is expected after the condition. ThenKeywordExpectedForElseifClause, /// When declaring a numeric for statement, the parser expects an expression after the assign /// symbol (`=`) to specify the starting value. StartExpressionExpectedForNumericFor, /// When declaring a numeric for statement, the parser expects an expression after the comma /// (`,`) to specify the ending value. EndExpressionExpectedForNumericFor, /// When declaring a numeric for statement, the parser expects an expression after the comma /// following the end expression. StepExpressionExpectedForNumericFor, /// When declaring a numeric for statement, the parser expects a comma after the start /// expression. CommaExpectedAfterStartExpressionOfNumericFor, /// When declaring a numeric for statement, the parser expects the keyword `do` after the /// ending expression or the step expression. DoExpectedForNumericFor, /// An identifier is expected after a `for` keyword. IdentifierExpectedAfterForKeyword, /// When parsing the identifier list of a generic for statement, the parser expects an /// identifier after each comma. IdentifierExpectedForGenericFor, /// After parsing the identifier list of a generic for statement, the parser expects the `in` /// keyword. InKeywordExpectedForGenericFor, /// After the `in` keyword, an expression is expected. ExpressionExpectedForGenericFor, /// After parsing the expression list of a generic for statement, the parser /// expects the `do` keyword. DoKeywordExpectedForGenericFor, /// When parsing a local assignement, the parser expects at least one identifier. IdentifierExpectedForLocalAssign, /// When parsing a function definition, an identifier is expected after the `function` keyword /// or after every dot (`.`) symbol in the function name. IdentifierExpectedForFunction, /// The parser expects an identifier to access a field of an expression. AssignSymbolExpectedForAssignStatement, /// When parsing an assign statement, the parser expects an expression after the assign (`=`) /// symbol and after each commas following an expression after the assign symbol. ExpressionExpectedForAssignStatement, /// After a comma following a variable in an assign statement, another variable is expected. VariableExpectedForAssignStatement, /// Wraps the error thrown by the tokenization process. Lexer(LexerErrorType), } pub type ParsingResult<'a, T> = Result<(T, &'a [Token<'a>]), ParsingError>; pub type OptionParsingResult<'a, T> = Result<Option<(T, &'a [Token<'a>])>, ParsingError>;