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>;