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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
use emmylua_parser::{
LuaAstNode, LuaClosureExpr, LuaLiteralExpr, LuaParseErrorKind, LuaSyntaxKind, LuaSyntaxToken,
LuaTokenKind, float_token_value, int_token_value,
};
use crate::{DiagnosticCode, LuaSignatureId, SemanticModel};
use super::{Checker, DiagnosticContext};
pub struct SyntaxErrorChecker;
impl Checker for SyntaxErrorChecker {
const CODES: &[DiagnosticCode] = &[DiagnosticCode::SyntaxError, DiagnosticCode::DocSyntaxError];
fn check(context: &mut DiagnosticContext, semantic_model: &SemanticModel) {
if let Some(parse_errors) = semantic_model.get_file_parse_error() {
for parse_error in parse_errors {
let code = match parse_error.kind {
LuaParseErrorKind::SyntaxError => DiagnosticCode::SyntaxError,
LuaParseErrorKind::DocError => DiagnosticCode::DocSyntaxError,
};
context.add_diagnostic(code, parse_error.range, parse_error.message, None);
}
}
let root = semantic_model.get_root();
for node_or_token in root.syntax().descendants_with_tokens() {
if let Some(token) = node_or_token.into_token() {
match token.kind().into() {
LuaTokenKind::TkInt => {
if let Err(err) = int_token_value(&token) {
context.add_diagnostic(
DiagnosticCode::SyntaxError,
err.range,
err.message,
None,
);
}
}
LuaTokenKind::TkFloat => {
if let Err(err) = float_token_value(&token) {
context.add_diagnostic(
DiagnosticCode::SyntaxError,
err.range,
err.message,
None,
);
}
}
LuaTokenKind::TkString => {
if let Err(err) = check_normal_string_error(&token) {
context.add_diagnostic(
DiagnosticCode::SyntaxError,
token.text_range(),
err,
None,
);
}
}
LuaTokenKind::TkDots => {
check_dots_literal_error(context, semantic_model, &token);
}
_ => {}
}
}
}
}
}
// this function is like string_token_value, but optimize for performance
fn check_normal_string_error(string_token: &LuaSyntaxToken) -> Result<(), String> {
let text = string_token.text();
if text.len() < 2 {
return Ok(());
}
let mut chars = text.chars().peekable();
let delimiter = match chars.next() {
Some(c) => c,
None => return Ok(()),
};
while let Some(c) = chars.next() {
match c {
'\\' => {
if let Some(next_char) = chars.next() {
match next_char {
'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' | '\\' | '\'' | '\"' | '\r'
| '\n' => {}
'x' => {
// Hexadecimal escape sequence
let hex = chars.by_ref().take(2).collect::<String>();
if hex.len() == 2 && hex.chars().all(|c| c.is_ascii_hexdigit()) {
if u8::from_str_radix(&hex, 16).is_err() {
return Err(t!(
"Invalid hex escape sequence '\\x%{hex}'",
hex = hex
)
.to_string());
}
} else {
return Err(t!(
"Invalid hex escape sequence '\\x%{hex}'",
hex = hex
)
.to_string());
}
}
'u' => {
// Unicode escape sequence
if let Some('{') = chars.next() {
let unicode_hex =
chars.by_ref().take_while(|c| *c != '}').collect::<String>();
if let Ok(code_point) = u32::from_str_radix(&unicode_hex, 16)
&& std::char::from_u32(code_point).is_none()
{
return Err(t!(
"Invalid unicode escape sequence '\\u{{%{unicode_hex}}}'",
unicode_hex = unicode_hex
)
.to_string());
}
}
}
'0'..='9' => {
// Decimal escape sequence
for _ in 0..2 {
if let Some(digit) = chars.peek() {
if !digit.is_ascii_digit() {
break;
}
chars.next();
}
}
}
'z' => {
// Skip whitespace
while let Some(c) = chars.peek() {
if !c.is_whitespace() {
break;
}
chars.next();
}
}
_ => {
// donot check other escape sequence
}
}
}
}
_ => {
if c == delimiter {
break;
}
}
}
}
Ok(())
}
fn check_dots_literal_error(
context: &mut DiagnosticContext,
semantic_model: &SemanticModel,
dots_token: &LuaSyntaxToken,
) -> Option<()> {
if let Some(literal_expr) = dots_token.parent() {
if literal_expr.kind() == LuaSyntaxKind::LiteralExpr.into() {
let literal_expr = LuaLiteralExpr::cast(literal_expr)?;
let closure_expr = literal_expr.ancestors::<LuaClosureExpr>().next()?;
let signature_id =
LuaSignatureId::from_closure(semantic_model.get_file_id(), &closure_expr);
let signature = context.db.get_signature_index().get(&signature_id)?;
if !signature.params.iter().any(|param| param == "...") {
context.add_diagnostic(
DiagnosticCode::SyntaxError,
literal_expr.get_range(),
t!("Cannot use `...` outside a vararg function.").to_string(),
None,
);
}
}
}
Some(())
}