1 /**
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "ETSparser.h"
17 #include "ETSNolintParser.h"
18 #include <utility>
19
20 #include "macros.h"
21 #include "parser/parserFlags.h"
22 #include "parser/parserStatusContext.h"
23 #include "util/errorRecovery.h"
24 #include "util/helpers.h"
25 #include "util/language.h"
26 #include "utils/arena_containers.h"
27 #include "varbinder/varbinder.h"
28 #include "varbinder/ETSBinder.h"
29 #include "lexer/lexer.h"
30 #include "lexer/ETSLexer.h"
31 #include "checker/types/ets/etsEnumType.h"
32 #include "ir/astNode.h"
33 #include "ir/base/classDefinition.h"
34 #include "ir/base/decorator.h"
35 #include "ir/base/catchClause.h"
36 #include "ir/base/classProperty.h"
37 #include "ir/base/scriptFunction.h"
38 #include "ir/base/methodDefinition.h"
39 #include "ir/base/classStaticBlock.h"
40 #include "ir/base/spreadElement.h"
41 #include "ir/expressions/identifier.h"
42 #include "ir/expressions/functionExpression.h"
43 #include "ir/statements/functionDeclaration.h"
44 #include "ir/statements/expressionStatement.h"
45 #include "ir/statements/classDeclaration.h"
46 #include "ir/statements/variableDeclarator.h"
47 #include "ir/statements/variableDeclaration.h"
48 #include "ir/expressions/dummyNode.h"
49 #include "ir/expressions/callExpression.h"
50 #include "ir/expressions/thisExpression.h"
51 #include "ir/expressions/typeofExpression.h"
52 #include "ir/expressions/memberExpression.h"
53 #include "ir/expressions/updateExpression.h"
54 #include "ir/expressions/arrowFunctionExpression.h"
55 #include "ir/expressions/unaryExpression.h"
56 #include "ir/expressions/yieldExpression.h"
57 #include "ir/expressions/awaitExpression.h"
58 #include "ir/expressions/literals/nullLiteral.h"
59 #include "ir/expressions/literals/numberLiteral.h"
60 #include "ir/expressions/literals/stringLiteral.h"
61 #include "ir/expressions/literals/undefinedLiteral.h"
62 #include "ir/module/importDeclaration.h"
63 #include "ir/module/importDefaultSpecifier.h"
64 #include "ir/module/importSpecifier.h"
65 #include "ir/module/exportSpecifier.h"
66 #include "ir/module/exportNamedDeclaration.h"
67 #include "ir/statements/annotationDeclaration.h"
68 #include "ir/statements/annotationUsage.h"
69 #include "ir/statements/assertStatement.h"
70 #include "ir/statements/blockStatement.h"
71 #include "ir/statements/ifStatement.h"
72 #include "ir/statements/labelledStatement.h"
73 #include "ir/statements/switchStatement.h"
74 #include "ir/statements/throwStatement.h"
75 #include "ir/statements/tryStatement.h"
76 #include "ir/statements/whileStatement.h"
77 #include "ir/statements/forOfStatement.h"
78 #include "ir/statements/doWhileStatement.h"
79 #include "ir/statements/breakStatement.h"
80 #include "ir/statements/debuggerStatement.h"
81 #include "ir/ets/etsLaunchExpression.h"
82 #include "ir/ets/etsClassLiteral.h"
83 #include "ir/ets/etsPrimitiveType.h"
84 #include "ir/ets/etsPackageDeclaration.h"
85 #include "ir/ets/etsReExportDeclaration.h"
86 #include "ir/ets/etsWildcardType.h"
87 #include "ir/ets/etsNewArrayInstanceExpression.h"
88 #include "ir/ets/etsTuple.h"
89 #include "ir/ets/etsFunctionType.h"
90 #include "ir/ets/etsNewClassInstanceExpression.h"
91 #include "ir/ets/etsNewMultiDimArrayInstanceExpression.h"
92 #include "ir/ets/etsScript.h"
93 #include "ir/ets/etsTypeReference.h"
94 #include "ir/ets/etsTypeReferencePart.h"
95 #include "ir/ets/etsNullishTypes.h"
96 #include "ir/ets/etsUnionType.h"
97 #include "ir/ets/etsImportSource.h"
98 #include "ir/ets/etsImportDeclaration.h"
99 #include "ir/ets/etsStructDeclaration.h"
100 #include "ir/ets/etsParameterExpression.h"
101 #include "ir/module/importNamespaceSpecifier.h"
102 #include "ir/ts/tsAsExpression.h"
103 #include "ir/ts/tsInterfaceDeclaration.h"
104 #include "ir/ts/tsEnumDeclaration.h"
105 #include "ir/ts/tsTypeParameterInstantiation.h"
106 #include "ir/ts/tsInterfaceBody.h"
107 #include "ir/ts/tsImportEqualsDeclaration.h"
108 #include "ir/ts/tsArrayType.h"
109 #include "ir/ts/tsQualifiedName.h"
110 #include "ir/ts/tsTypeReference.h"
111 #include "ir/ts/tsTypeParameter.h"
112 #include "ir/ts/tsInterfaceHeritage.h"
113 #include "ir/ts/tsFunctionType.h"
114 #include "ir/ts/tsClassImplements.h"
115 #include "ir/ts/tsEnumMember.h"
116 #include "ir/ts/tsTypeAliasDeclaration.h"
117 #include "ir/ts/tsTypeParameterDeclaration.h"
118 #include "ir/ts/tsNonNullExpression.h"
119 #include "ir/ts/tsThisType.h"
120 #include "generated/signatures.h"
121
122 namespace ark::es2panda::parser {
123 class FunctionContext;
124
125 using namespace std::literals::string_literals;
126
ParseTopLevelStatements()127 ArenaVector<ir::Statement *> ETSParser::ParseTopLevelStatements()
128 {
129 ArenaVector<ir::Statement *> statements(Allocator()->Adapter());
130 while (Lexer()->GetToken().Type() != lexer::TokenType::EOS) {
131 util::ErrorRecursionGuard infiniteLoopBlocker(Lexer());
132
133 if (Lexer()->TryEatTokenType(lexer::TokenType::PUNCTUATOR_SEMI_COLON)) {
134 continue;
135 }
136 auto stmt = ParseTopLevelStatement();
137 GetContext().Status() &= ~ParserStatus::IN_AMBIENT_CONTEXT;
138 if (stmt != nullptr) {
139 statements.emplace_back(stmt);
140 }
141 }
142
143 return statements;
144 }
145
ValidateExportableStatement(ETSParser * parser,ir::Statement * stmt,ark::es2panda::ir::ModifierFlags memberModifiers,lexer::SourcePosition pos)146 static ir::Statement *ValidateExportableStatement(ETSParser *parser, ir::Statement *stmt,
147 ark::es2panda::ir::ModifierFlags memberModifiers,
148 lexer::SourcePosition pos)
149 {
150 if (stmt != nullptr) {
151 if ((memberModifiers & ir::ModifierFlags::EXPORT_TYPE) != 0U &&
152 !(stmt->IsClassDeclaration() || stmt->IsTSInterfaceDeclaration() || stmt->IsTSTypeAliasDeclaration())) {
153 parser->LogSyntaxError("Can only type export class or interface!", stmt->Start());
154 }
155 if (stmt->IsAnnotationDeclaration()) {
156 if ((memberModifiers & ir::ModifierFlags::DEFAULT_EXPORT) != 0U) {
157 parser->LogSyntaxError("Can not export annotation default!", stmt->Start());
158 }
159 }
160 stmt->AddModifier(memberModifiers);
161 } else {
162 if ((memberModifiers &
163 (ir::ModifierFlags::EXPORT | ir::ModifierFlags::DEFAULT_EXPORT | ir::ModifierFlags::EXPORT_TYPE)) != 0U) {
164 parser->LogSyntaxError("Export is allowed only for declarations.", pos);
165 }
166 }
167
168 return stmt;
169 }
170
ParseAnnotation(StatementParsingFlags flags,ir::ModifierFlags memberModifiers)171 ir::Statement *ETSParser::ParseAnnotation(StatementParsingFlags flags, ir::ModifierFlags memberModifiers)
172 {
173 ir::Statement *result = nullptr;
174
175 Lexer()->NextToken(); // eat '@'
176 if (Lexer()->GetToken().Type() == lexer::TokenType::KEYW_INTERFACE) {
177 result = ParseAnnotationDeclaration(memberModifiers);
178 } else {
179 auto annotations = ParseAnnotations(memberModifiers);
180 auto savePos = Lexer()->GetToken().Start();
181 result = ParseTopLevelDeclStatement(flags);
182 if (result != nullptr) {
183 ApplyAnnotationsToNode(result, std::move(annotations), savePos);
184 }
185 }
186
187 return result;
188 }
189
ParseTopLevelDeclStatement(StatementParsingFlags flags)190 ir::Statement *ETSParser::ParseTopLevelDeclStatement(StatementParsingFlags flags)
191 {
192 auto [memberModifiers, startLoc] = ParseMemberModifiers();
193 if ((memberModifiers & (ir::ModifierFlags::EXPORTED)) != 0U &&
194 (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_MULTIPLY ||
195 Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_LEFT_BRACE)) {
196 return ParseExport(startLoc, memberModifiers);
197 }
198
199 ir::Statement *result = nullptr;
200 auto token = Lexer()->GetToken();
201 switch (token.Type()) {
202 case lexer::TokenType::KEYW_FUNCTION: {
203 if (result = ParseFunctionDeclaration(false, memberModifiers); result != nullptr) { // Error processing.
204 result->SetStart(startLoc);
205 }
206 break;
207 }
208 case lexer::TokenType::KEYW_CONST:
209 memberModifiers |= ir::ModifierFlags::CONST;
210 [[fallthrough]];
211 case lexer::TokenType::KEYW_LET:
212 result = ParseStatement(flags);
213 break;
214 case lexer::TokenType::KEYW_NAMESPACE:
215 case lexer::TokenType::KEYW_STATIC:
216 case lexer::TokenType::KEYW_ABSTRACT:
217 case lexer::TokenType::KEYW_FINAL:
218 case lexer::TokenType::KEYW_ENUM:
219 case lexer::TokenType::KEYW_INTERFACE:
220 case lexer::TokenType::KEYW_CLASS:
221 result = ParseTypeDeclaration(false);
222 break;
223 case lexer::TokenType::PUNCTUATOR_AT:
224 result = ParseAnnotation(flags, memberModifiers);
225 break;
226 case lexer::TokenType::LITERAL_IDENT: {
227 result = ParseIdentKeyword();
228 if (result == nullptr && (memberModifiers & (ir::ModifierFlags::EXPORTED)) != 0U) {
229 return ParseExport(startLoc, memberModifiers);
230 }
231 break;
232 }
233 default: {
234 }
235 }
236
237 return ValidateExportableStatement(this, result, memberModifiers, startLoc);
238 }
239
ParseTopLevelStatement()240 ir::Statement *ETSParser::ParseTopLevelStatement()
241 {
242 const auto flags = StatementParsingFlags::ALLOW_LEXICAL;
243
244 auto result = ParseTopLevelDeclStatement(flags);
245 if (result == nullptr) {
246 result = ParseStatement(flags);
247 }
248 return result;
249 }
250
ParseTopLevelDeclaration()251 ArenaVector<ir::Statement *> ETSParser::ParseTopLevelDeclaration()
252 {
253 auto topStatements = ParseTopLevelStatements();
254 Lexer()->NextToken();
255 return topStatements;
256 }
257
ValidateLabeledStatement(lexer::TokenType type)258 bool ETSParser::ValidateLabeledStatement(lexer::TokenType type)
259 {
260 if (type != lexer::TokenType::KEYW_DO && type != lexer::TokenType::KEYW_WHILE &&
261 type != lexer::TokenType::KEYW_FOR && type != lexer::TokenType::KEYW_SWITCH) {
262 LogSyntaxError("Label must be followed by a loop statement", Lexer()->GetToken().Start());
263 return false;
264 }
265
266 return true;
267 }
268
ValidateForInStatement()269 bool ETSParser::ValidateForInStatement()
270 {
271 LogSyntaxError({"Unexpected token: '", lexer::TokenToString(lexer::TokenType::KEYW_IN), "'."});
272 return false;
273 }
274
ParseDebuggerStatement()275 ir::DebuggerStatement *ETSParser::ParseDebuggerStatement()
276 {
277 LogSyntaxError({"Unexpected token: '", lexer::TokenToString(lexer::TokenType::KEYW_DEBUGGER), "'."});
278 return nullptr;
279 }
280
ParseFunctionStatement(const StatementParsingFlags flags)281 ir::Statement *ETSParser::ParseFunctionStatement(const StatementParsingFlags flags)
282 {
283 ASSERT((flags & StatementParsingFlags::GLOBAL) == 0);
284 LogSyntaxError("Nested functions are not allowed");
285 ParserImpl::ParseFunctionStatement(flags); // Try to parse function body but skip result.
286 return nullptr;
287 }
288
ParseAssertStatement()289 ir::Statement *ETSParser::ParseAssertStatement()
290 {
291 lexer::SourcePosition startLoc = Lexer()->GetToken().Start();
292 Lexer()->NextToken();
293
294 ir::Expression *test = ParseExpression();
295 if (test == nullptr) { // Error processing.
296 return nullptr;
297 }
298
299 lexer::SourcePosition endLoc = test->End();
300 ir::Expression *second = nullptr;
301
302 if (Lexer()->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COLON) {
303 Lexer()->NextToken(); // eat ':'
304 second = ParseExpression();
305 if (second != nullptr) { // Error processing.
306 endLoc = second->End();
307 }
308 }
309
310 auto *asStatement = AllocNode<ir::AssertStatement>(test, second);
311 asStatement->SetRange({startLoc, endLoc});
312 ConsumeSemicolon(asStatement);
313
314 return asStatement;
315 }
316
ParseTryStatement()317 ir::Statement *ETSParser::ParseTryStatement()
318 {
319 lexer::SourcePosition startLoc = Lexer()->GetToken().Start();
320 Lexer()->NextToken(); // eat the 'try' keyword
321
322 ir::BlockStatement *body = ParseBlockStatement();
323
324 ArenaVector<ir::CatchClause *> catchClauses(Allocator()->Adapter());
325
326 while (Lexer()->GetToken().KeywordType() == lexer::TokenType::KEYW_CATCH) {
327 ir::CatchClause *clause {};
328
329 clause = ParseCatchClause();
330
331 catchClauses.push_back(clause);
332 }
333
334 ir::BlockStatement *finalizer = nullptr;
335 if (Lexer()->GetToken().KeywordType() == lexer::TokenType::KEYW_FINALLY) {
336 Lexer()->NextToken(); // eat 'finally' keyword
337
338 finalizer = ParseBlockStatement();
339 }
340
341 if (catchClauses.empty() && finalizer == nullptr) {
342 LogSyntaxError("A try statement should contain either finally clause or at least one catch clause.", startLoc);
343 return nullptr;
344 }
345
346 lexer::SourcePosition endLoc = finalizer != nullptr ? finalizer->End() : catchClauses.back()->End();
347
348 ArenaVector<std::pair<compiler::LabelPair, const ir::Statement *>> finalizerInsertions(Allocator()->Adapter());
349
350 auto *tryStatement = AllocNode<ir::TryStatement>(body, std::move(catchClauses), finalizer, finalizerInsertions);
351 tryStatement->SetRange({startLoc, endLoc});
352 ConsumeSemicolon(tryStatement);
353
354 return tryStatement;
355 }
356
357 // NOLINTNEXTLINE(google-default-arguments)
ParseClassStatement(StatementParsingFlags flags,ir::ClassDefinitionModifiers modifiers,ir::ModifierFlags modFlags)358 ir::ClassDeclaration *ETSParser::ParseClassStatement([[maybe_unused]] StatementParsingFlags flags,
359 ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags modFlags)
360 {
361 modFlags |= ParseClassModifiers();
362 return ParseClassDeclaration(modifiers | ir::ClassDefinitionModifiers::ID_REQUIRED |
363 ir::ClassDefinitionModifiers::CLASS_DECL | ir::ClassDefinitionModifiers::LOCAL,
364 modFlags);
365 }
366
367 // NOLINTNEXTLINE(google-default-arguments)
ParseStructStatement(StatementParsingFlags flags,ir::ClassDefinitionModifiers modifiers,ir::ModifierFlags modFlags)368 ir::ETSStructDeclaration *ETSParser::ParseStructStatement([[maybe_unused]] StatementParsingFlags flags,
369 ir::ClassDefinitionModifiers modifiers,
370 ir::ModifierFlags modFlags)
371 {
372 LogSyntaxError("Illegal start of STRUCT expression", Lexer()->GetToken().Start());
373 ParseClassDeclaration(modifiers | ir::ClassDefinitionModifiers::ID_REQUIRED |
374 ir::ClassDefinitionModifiers::CLASS_DECL | ir::ClassDefinitionModifiers::LOCAL,
375 modFlags); // Try to parse struct and drop the result.
376 return nullptr;
377 }
378
379 } // namespace ark::es2panda::parser
380