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 #ifndef ES2PANDA_PARSER_CORE_PARSER_IMPL_H
17 #define ES2PANDA_PARSER_CORE_PARSER_IMPL_H
18
19 #include "varbinder/varbinder.h"
20 #include "es2panda.h"
21 #include "ir/astNode.h"
22 #include "ir/base/scriptFunctionSignature.h"
23 #include "lexer/token/sourceLocation.h"
24 #include "lexer/token/tokenType.h"
25 #include "macros.h"
26 #include "mem/arena_allocator.h"
27 #include "parser/context/classPrivateContext.h"
28 #include "parser/context/parserContext.h"
29 #include "parser/parserFlags.h"
30 #include "parser/program/program.h"
31 #include "util/enumbitops.h"
32 #include "util/ustring.h"
33
34 #include <memory>
35 #include <sstream>
36 #include <unordered_map>
37 #include <unordered_set>
38
39 namespace panda::es2panda::lexer {
40 enum class TokenFlags : uint32_t;
41 class LexerPosition;
42 class Token;
43 class Lexer;
44 } // namespace panda::es2panda::lexer
45
46 namespace panda::es2panda::ir {
47 class ArrowFunctionExpression;
48 class AstNode;
49 class BlockStatement;
50 class BreakStatement;
51 class CallExpression;
52 class ClassDeclaration;
53 class ClassDefinition;
54 class ContinueStatement;
55 class DoWhileStatement;
56 class ExportAllDeclaration;
57 class ExportDefaultDeclaration;
58 class ExportNamedDeclaration;
59 class ExportNamedDeclaration;
60 class Expression;
61 class FunctionDeclaration;
62 class FunctionExpression;
63 class Identifier;
64 class IfStatement;
65 class ImportSource;
66 class ImportDeclaration;
67 class LabelledStatement;
68 class NewExpression;
69 class ObjectExpression;
70 class ReturnStatement;
71 class ScriptFunction;
72 class SequenceExpression;
73 class SpreadElement;
74 class Statement;
75 class StringLiteral;
76 class SwitchCaseStatement;
77 class SwitchStatement;
78 class TemplateLiteral;
79 class ThrowStatement;
80 class TryStatement;
81 class VariableDeclaration;
82 class WhileStatement;
83 class WithStatement;
84 class MemberExpression;
85 class MethodDefinition;
86 class Property;
87 class YieldExpression;
88 class MetaProperty;
89 class EmptyStatement;
90 class DebuggerStatement;
91 class CatchClause;
92 class VariableDeclarator;
93 class ClassElement;
94
95 enum class PropertyKind;
96 enum class MethodDefinitionKind;
97 enum class ModifierFlags : uint32_t;
98 enum class Primitives;
99 enum class ClassDefinitionModifiers : uint32_t;
100 enum class CatchClauseType;
101 enum class VariableDeclaratorFlag;
102 } // namespace panda::es2panda::ir
103
104 namespace panda::es2panda::parser {
105
106 class ETSParser;
107
108 using FunctionSignature = std::tuple<ir::FunctionSignature, panda::es2panda::ir::ScriptFunctionFlags>;
109
110 class ClassElementDescriptor {
111 public:
ClassElementDescriptor(ArenaAllocator * allocator)112 explicit ClassElementDescriptor(ArenaAllocator *allocator) : decorators(allocator->Adapter()) {}
113
114 // NOLINTBEGIN(misc-non-private-member-variables-in-classes)
115 ArenaVector<ir::Decorator *> decorators;
116 ir::MethodDefinitionKind methodKind {};
117 ParserStatus newStatus {};
118 ir::ModifierFlags modifiers {};
119 lexer::SourcePosition methodStart {};
120 lexer::SourcePosition propStart {};
121 bool isPrivateIdent {};
122 bool hasSuperClass {};
123 bool isGenerator {};
124 bool invalidComputedProperty {};
125 bool isComputed {};
126 bool isIndexSignature {};
127 bool classMethod {};
128 bool classField {};
129 varbinder::LocalScope *staticFieldScope {};
130 varbinder::LocalScope *staticMethodScope {};
131 varbinder::LocalScope *instanceFieldScope {};
132 varbinder::LocalScope *instanceMethodScope {};
133 // NOLINTEND(misc-non-private-member-variables-in-classes)
134 };
135
136 class ArrowFunctionDescriptor {
137 public:
ArrowFunctionDescriptor(ArenaVector<ir::Expression * > && p,lexer::SourcePosition sl,ParserStatus ns)138 explicit ArrowFunctionDescriptor(ArenaVector<ir::Expression *> &&p, lexer::SourcePosition sl, ParserStatus ns)
139 : params(p), startLoc(sl), newStatus(ns)
140 {
141 }
142
143 // NOLINTBEGIN(misc-non-private-member-variables-in-classes)
144 ArenaVector<ir::Expression *> params;
145 lexer::SourcePosition startLoc;
146 ParserStatus newStatus;
147 // NOLINTEND(misc-non-private-member-variables-in-classes)
148 };
149
150 enum class TypeAnnotationParsingOptions : uint32_t {
151 NO_OPTS = 0U,
152 IN_UNION = 1U << 0U,
153 ALLOW_CONST = 1U << 1U,
154 IN_INTERSECTION = 1U << 2U,
155 RESTRICT_EXTENDS = 1U << 3U,
156 THROW_ERROR = 1U << 4U,
157 CAN_BE_TS_TYPE_PREDICATE = 1U << 5U,
158 BREAK_AT_NEW_LINE = 1U << 6U,
159 RETURN_TYPE = 1U << 7U,
160 POTENTIAL_CLASS_LITERAL = 1U << 8U,
161 ALLOW_INTERSECTION = 1U << 9U,
162 ADD_TYPE_PARAMETER_BINDING = 1U << 10U,
163 DISALLOW_PRIMARY_TYPE = 1U << 11U,
164 ALLOW_WILDCARD = 1U << 12U,
165 IGNORE_FUNCTION_TYPE = 1U << 13U,
166 ALLOW_DECLARATION_SITE_VARIANCE = 1U << 14U,
167 DISALLOW_UNION = 1U << 15U,
168 };
169
DEFINE_BITOPS(TypeAnnotationParsingOptions)170 DEFINE_BITOPS(TypeAnnotationParsingOptions)
171
172 class ArrowFunctionContext;
173
174 class ParserImpl {
175 public:
176 explicit ParserImpl(Program *program, const CompilerOptions &options, ParserStatus status = ParserStatus::NO_OPTS);
177 NO_COPY_SEMANTIC(ParserImpl);
178 NO_MOVE_SEMANTIC(ParserImpl);
179 virtual ~ParserImpl() = default;
180
181 void ParseScript(const SourceFile &sourceFile, bool genStdLib);
182
183 ScriptExtension Extension() const;
184
185 [[nodiscard]] virtual bool IsETSParser() const noexcept
186 {
187 return false;
188 }
189
190 ETSParser *AsETSParser()
191 {
192 ASSERT(IsETSParser());
193 return reinterpret_cast<ETSParser *>(this);
194 }
195
196 const ETSParser *AsETSParser() const
197 {
198 ASSERT(IsETSParser());
199 return reinterpret_cast<const ETSParser *>(this);
200 }
201
202 protected:
203 virtual void ParseProgram(ScriptKind kind);
204 static ExpressionParseFlags CarryExpressionParserFlag(ExpressionParseFlags origin, ExpressionParseFlags carry);
205 static ExpressionParseFlags CarryPatternFlags(ExpressionParseFlags flags);
206
207 void ThrowIfPrivateIdent(ClassElementDescriptor *desc, const char *msg);
208 void ValidateClassKey(ClassElementDescriptor *desc);
209 void ValidatePrivateIdentifier();
210
211 static ir::VariableDeclaratorFlag GetFlag(VariableParsingFlags flags);
212 ir::MethodDefinition *CheckClassMethodOverload(ir::Statement *property, ir::MethodDefinition **ctor,
213 lexer::SourcePosition errorInfo, ir::MethodDefinition *lastOverload,
214 bool implExists, bool isAbstract = false);
215
216 void ThrowAllocationError(std::string_view message) const;
217
218 void ValidateAccessor(ExpressionParseFlags flags, lexer::TokenFlags currentTokenFlags);
219 void CheckPropertyKeyAsyncModifier(ParserStatus *methodStatus);
220 ir::Property *ParseShorthandProperty(const lexer::LexerPosition *startPos);
221 void ParseGeneratorPropertyModifier(ExpressionParseFlags flags, ParserStatus *methodStatus);
222 bool ParsePropertyModifiers(ExpressionParseFlags flags, ir::PropertyKind *propertyKind, ParserStatus *methodStatus);
223 ir::Expression *ParsePropertyValue(const ir::PropertyKind *propertyKind, const ParserStatus *methodStatus,
224 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
225 bool ParsePropertyEnd();
226
227 // ExpressionParser.Cpp
228
229 ir::Expression *ParseKeywordExpression();
230 ir::Expression *ParseBinaryExpression(ir::Expression *left,
231 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
232 void ValidateUpdateExpression(ir::Expression *returnExpression, bool isChainExpression);
233 ir::Expression *ParseMemberExpression(bool ignoreCallExpression = false,
234 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
235 ir::MetaProperty *ParsePotentialNewTarget();
236 void CheckInvalidDestructuring(const ir::AstNode *object) const;
237 void ValidateParenthesizedExpression(ir::Expression *lhsExpression);
238 void ValidateGroupedExpression(ir::Expression *lhsExpression);
239 ir::Expression *ParseImportExpression();
240 ir::Expression *ParseOptionalChain(ir::Expression *leftSideExpr);
241 ir::Expression *ParsePropertyKey(ExpressionParseFlags flags);
242 void ValidateAssignmentTarget(ExpressionParseFlags flags, ir::Expression *node);
243 void ValidateLvalueAssignmentTarget(ir::Expression *node);
244 void ValidateArrowParameterBindings(const ir::Expression *node);
245 ir::Identifier *ParseNamedExport(const lexer::Token &exportedToken);
246 virtual void ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr) {}
247
248 // StatementParser.Cpp
249
250 void CheckFunctionDeclaration(StatementParsingFlags flags);
251 void CheckLabelledFunction(const ir::Statement *node);
252 bool ParseDirective(ArenaVector<ir::Statement *> *statements);
253 void ParseDirectivePrologue(ArenaVector<ir::Statement *> *statements);
254 ir::BlockStatement *ParseFunctionBody();
255 std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *> ParseForInOf(
256 ir::Expression *leftNode, ExpressionParseFlags exprFlags, bool isAwait);
257 std::tuple<ForStatementKind, ir::Expression *, ir::Expression *> ParseForInOf(ir::AstNode *initNode,
258 ExpressionParseFlags exprFlags,
259 bool isAwait);
260 std::tuple<ir::Expression *, ir::Expression *> ParseForUpdate(bool isAwait);
261 ir::SwitchCaseStatement *ParseSwitchCaseStatement(bool *seenDefault);
262 virtual ir::Expression *ParseCatchParam();
263 ir::CatchClause *ParseCatchClause();
264 ir::VariableDeclaration *ParseContextualLet(VariableParsingFlags flags,
265 StatementParsingFlags stmFlags = StatementParsingFlags::ALLOW_LEXICAL);
266
267 friend class Lexer;
268 friend class SavedParserContext;
269 friend class SavedClassPrivateContext;
270 friend class ArrowFunctionContext;
271
272 [[noreturn]] void ThrowParameterModifierError(ir::ModifierFlags status) const;
273 [[noreturn]] void ThrowUnexpectedToken(lexer::TokenType tokenType) const;
274 [[noreturn]] void ThrowExpectedToken(lexer::TokenType tokenType) const;
275 [[noreturn]] void ThrowSyntaxError(std::string_view errorMessage) const;
276 [[noreturn]] void ThrowSyntaxError(std::initializer_list<std::string_view> list) const;
277 [[noreturn]] void ThrowSyntaxError(std::initializer_list<std::string_view> list,
278 const lexer::SourcePosition &pos) const;
279
280 [[noreturn]] void ThrowSyntaxError(std::string_view errorMessage, const lexer::SourcePosition &pos) const;
281
282 template <typename T, typename... Args>
283 T *AllocNodeNoSetParent(Args &&...args)
284 {
285 auto *ret = program_->Allocator()->New<T>(std::forward<Args>(args)...);
286 if (ret == nullptr) {
287 ThrowAllocationError("Unsuccessful allocation during parsing");
288 }
289
290 return ret;
291 }
292
293 template <typename T, typename... Args>
294 T *AllocNode(Args &&...args)
295 {
296 auto *ret = AllocNodeNoSetParent<T>(std::forward<Args>(args)...);
297 ret->Iterate([ret](auto *child) { child->SetParent(ret); });
298
299 return ret;
300 }
301
302 ArenaAllocator *Allocator() const
303 {
304 return program_->Allocator();
305 }
306
307 bool CheckModuleAsModifier();
308
309 ir::Identifier *ExpectIdentifier(bool isReference = false, bool isUserDefinedType = false);
310 void ExpectToken(lexer::TokenType tokenType, bool consumeToken = true);
311
312 // ExpressionParser.cpp
313
314 ir::SpreadElement *ParseSpreadElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
315 ir::YieldExpression *ParseYieldExpression();
316 virtual ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags);
317 ir::ArrowFunctionExpression *ParseArrowFunctionExpressionBody(ArrowFunctionContext *arrowFunctionContext,
318 ArrowFunctionDescriptor *desc,
319 ir::TSTypeParameterDeclaration *typeParamDecl,
320 ir::TypeNode *returnTypeAnnotation);
321 ir::Expression *ParseAssignmentExpression(ir::Expression *expression,
322 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
323 ir::SequenceExpression *ParseSequenceExpression(ir::Expression *startExpr, bool acceptRest = false);
324 ir::FunctionExpression *ParseFunctionExpression(ParserStatus newStatus = ParserStatus::NO_OPTS);
325 ir::ArrowFunctionExpression *ParseArrowFunctionExpression(ir::Expression *expr,
326 ir::TSTypeParameterDeclaration *typeParamDecl,
327 ir::TypeNode *returnTypeAnnotation, bool isAsync);
328 ir::CallExpression *ParseCallExpression(ir::Expression *callee, bool isOptionalChain = false,
329 bool handleEval = true);
330 ir::TemplateLiteral *ParseTemplateLiteral();
331 ir::Expression *ParseLeftHandSideExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
332 void ParseNameSpaceImport(ArenaVector<ir::AstNode *> *specifiers);
333 void ParseNamedImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
334 ir::StringLiteral *ParseFromClause(bool requireFrom = true);
335
336 ir::BooleanLiteral *ParseBooleanLiteral();
337 ir::NullLiteral *ParseNullLiteral();
338 ir::Literal *ParseNumberLiteral();
339 ir::CharLiteral *ParseCharLiteral();
340 ir::StringLiteral *ParseStringLiteral();
341 ir::UndefinedLiteral *ParseUndefinedLiteral();
342 virtual ir::ThisExpression *ParseThisExpression();
343 ir::RegExpLiteral *ParseRegularExpression();
344 ir::SuperExpression *ParseSuperExpression();
345 ir::MemberExpression *ParseElementAccess(ir::Expression *primaryExpr, bool isOptional = false);
346 ir::MemberExpression *ParsePrivatePropertyAccess(ir::Expression *primaryExpr);
347 ir::MemberExpression *ParsePropertyAccess(ir::Expression *primaryExpr, bool isOptional = false);
348 void CreateAmendedBinaryExpression(ir::Expression *left, ir::Expression *right, lexer::TokenType operatorType);
349
350 // StatementParser
351 ArenaVector<ir::Statement *> ParseStatementList(StatementParsingFlags flags = StatementParsingFlags::ALLOW_LEXICAL);
352 virtual ir::Statement *ParseAssertStatement();
353 virtual void ValidateLabeledStatement(lexer::TokenType type);
354 ir::BlockStatement *ParseBlockStatement();
355 ir::EmptyStatement *ParseEmptyStatement();
356 ir::Statement *ParseForStatement();
357 ir::IfStatement *ParseIfStatement();
358 virtual ir::Statement *ParseFunctionStatement(StatementParsingFlags flags);
359 // NOLINTNEXTLINE(google-default-arguments)
360 virtual ir::ClassDeclaration *ParseClassStatement(StatementParsingFlags flags,
361 ir::ClassDefinitionModifiers modifiers,
362 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE);
363 // NOLINTNEXTLINE(google-default-arguments)
364 virtual ir::ETSStructDeclaration *ParseStructStatement(StatementParsingFlags flags,
365 ir::ClassDefinitionModifiers modifiers,
366 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE);
367 ir::Statement *ParseVarStatement();
368 ir::Statement *ParseLetStatement(StatementParsingFlags flags);
369 ir::BreakStatement *ParseBreakStatement();
370 ir::ContinueStatement *ParseContinueStatement();
371 ir::DoWhileStatement *ParseDoWhileStatement();
372 ir::WhileStatement *ParseWhileStatement();
373 ir::SwitchStatement *ParseSwitchStatement();
374 ir::ReturnStatement *ParseReturnStatement();
375 ir::Statement *ParseExpressionStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
376 ir::LabelledStatement *ParseLabelledStatement(const lexer::LexerPosition &pos);
377 virtual void ValidateRestParameter(ir::Expression *param);
378 bool InAmbientContext();
379
380 ir::MethodDefinition *BuildImplicitConstructor(ir::ClassDefinitionModifiers modifiers,
381 const lexer::SourcePosition &startLoc);
382
383 virtual void CreateImplicitConstructor(ir::MethodDefinition *&ctor, ArenaVector<ir::AstNode *> &properties,
384 ir::ClassDefinitionModifiers modifiers,
385 const lexer::SourcePosition &startLoc);
386 void CheckClassGeneratorMethod(ClassElementDescriptor *desc, char32_t *nextCp);
387 void ParseClassAccessor(ClassElementDescriptor *desc, char32_t *nextCp);
388 ir::Expression *ParseClassKey(ClassElementDescriptor *desc);
389 ir::ClassElement *ParseClassProperty(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
390 ir::Expression *propName, ir::TypeNode *typeAnnotation);
391 void AddPrivateElement(const ir::ClassElement *elem);
392 ir::ScriptFunction *ParseFunction(ParserStatus newStatus = ParserStatus::NO_OPTS);
393 ir::ModifierFlags GetAccessability(ir::ModifierFlags modifiers);
394 void CheckAccessorPair(const ArenaVector<ir::AstNode *> &properties, const ir::Expression *propName,
395 ir::MethodDefinitionKind methodKind, ir::ModifierFlags access);
396 ir::Identifier *ParseNamedImport(const lexer::Token &importedToken);
397 void ConsumeSemicolon(ir::Statement *statement);
398 ir::ExportAllDeclaration *ParseExportAllDeclaration(const lexer::SourcePosition &startLoc);
399 ir::ExportNamedDeclaration *ParseExportNamedSpecifiers(const lexer::SourcePosition &startLoc);
400 ir::Statement *ParseVariableDeclaration(VariableParsingFlags flags = VariableParsingFlags::NO_OPTS);
401 void ValidateDeclaratorId();
402 void CheckRestrictedBinding();
403 void CheckRestrictedBinding(lexer::TokenType keywordType);
404 void CheckRestrictedBinding(const util::StringView &ident, const lexer::SourcePosition &pos);
405
406 ir::VariableDeclarator *ParseVariableDeclarator(VariableParsingFlags flags);
407 ir::FunctionDeclaration *ParseFunctionDeclaration(bool canBeAnonymous = false,
408 ParserStatus newStatus = ParserStatus::NO_OPTS);
409 ir::ETSStructDeclaration *ParseStructDeclaration(ir::ClassDefinitionModifiers modifiers,
410 ir::ModifierFlags flags = ir::ModifierFlags::NONE);
411 ir::ClassDeclaration *ParseClassDeclaration(ir::ClassDefinitionModifiers modifiers,
412 ir::ModifierFlags flags = ir::ModifierFlags::NONE);
413 FunctionSignature ParseFunctionSignature(ParserStatus status, ir::Identifier *className = nullptr);
414
415 [[nodiscard]] virtual std::unique_ptr<lexer::Lexer> InitLexer(const SourceFile &sourceFile);
416 // NOLINTNEXTLINE(google-default-arguments)
417 virtual ir::Statement *ParseStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
418 // NOLINTNEXTLINE(google-default-arguments)
419 virtual ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
420 // NOLINTNEXTLINE(google-default-arguments)
421 virtual ir::Expression *ParsePatternElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS,
422 bool allowDefault = true);
423 virtual bool ParsePotentialNonNullExpression(ir::Expression **returnExpression, lexer::SourcePosition startLoc);
424 virtual ir::AstNode *ParseImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
425 virtual ir::Statement *ParseImportDeclaration(StatementParsingFlags flags);
426 // NOLINTNEXTLINE(google-default-arguments)
427 virtual ir::Expression *ParsePropertyDefinition(
428 [[maybe_unused]] ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
429 // NOLINTNEXTLINE(google-default-arguments)
430 virtual ir::ObjectExpression *ParseObjectExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
431 // NOLINTNEXTLINE(google-default-arguments)
432 virtual ir::ArrayExpression *ParseArrayExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
433 virtual ir::ArrowFunctionExpression *ParsePotentialArrowExpression(ir::Expression **returnExpression,
434 const lexer::SourcePosition &startLoc);
435 virtual bool ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir::Expression **returnExpression,
436 const lexer::SourcePosition &startLoc, bool ignoreCallExpression);
437 virtual ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpr);
438 virtual bool IsNamedFunctionExpression();
439 virtual ir::Identifier *ParsePrimaryExpressionIdent(ExpressionParseFlags flags);
440 virtual void ValidateArrowFunctionRestParameter(ir::SpreadElement *restElement);
441 virtual ir::Statement *ParsePotentialExpressionStatement(StatementParsingFlags flags);
442 virtual ArenaVector<ir::Expression *> ParseFunctionParams();
443 virtual ir::Expression *CreateParameterThis(util::StringView className);
444 virtual ir::Expression *ParseFunctionParameter();
445 virtual void ConvertThisKeywordToIdentIfNecessary() {}
446 virtual void ParseCatchParamTypeAnnotation(ir::AnnotatedExpression *param);
447 // NOLINTNEXTLINE(google-default-arguments)
448 virtual ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers,
449 ir::ModifierFlags flags = ir::ModifierFlags::NONE);
450 virtual ir::Identifier *ParseClassIdent(ir::ClassDefinitionModifiers modifiers);
451 virtual ir::Statement *ParsePotentialConstEnum(VariableParsingFlags flags);
452 // NOLINTNEXTLINE(google-default-arguments)
453 virtual ir::AstNode *ParseClassElement(const ArenaVector<ir::AstNode *> &properties,
454 ir::ClassDefinitionModifiers modifiers,
455 ir::ModifierFlags flags = ir::ModifierFlags::NONE,
456 ir::Identifier *identNode = nullptr);
457 virtual bool CheckClassElement(ir::AstNode *property, ir::MethodDefinition *&ctor,
458 ArenaVector<ir::AstNode *> &properties);
459 virtual void ValidateClassMethodStart(ClassElementDescriptor *desc, ir::TypeNode *typeAnnotation);
460 virtual ir::MethodDefinition *ParseClassMethod(ClassElementDescriptor *desc,
461 const ArenaVector<ir::AstNode *> &properties,
462 ir::Expression *propName, lexer::SourcePosition *propEnd);
463 virtual void ValidateClassSetter(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
464 ir::Expression *propName, ir::ScriptFunction *func);
465 virtual void ValidateClassGetter(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
466 ir::Expression *propName, ir::ScriptFunction *func);
467 virtual ir::ModifierFlags ParseModifiers();
468 virtual ir::Statement *ParseConstStatement(StatementParsingFlags flags);
469
470 virtual ir::AnnotatedExpression *ParseVariableDeclaratorKey(VariableParsingFlags flags);
471 virtual ir::VariableDeclarator *ParseVariableDeclarator(ir::Expression *init, lexer::SourcePosition startLoc,
472 VariableParsingFlags flags);
473 virtual ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags,
474 const lexer::SourcePosition &startLoc);
475 virtual bool IsModifierKind(const lexer::Token &token);
476 virtual void ConsumeClassPrivateIdentifier(ClassElementDescriptor *desc, char32_t *nextCp);
477 virtual void ThrowPossibleOutOfBoundaryJumpError(bool allowBreak);
478 virtual void ThrowIllegalBreakError();
479 virtual void ThrowIllegalContinueError();
480 virtual void ThrowIfBodyEmptyError(ir::Statement *consequent);
481 virtual void ThrowMultipleDefaultError();
482 virtual void ThrowIllegalNewLineErrorAfterThrow();
483 virtual void ThrowIfVarDeclaration(VariableParsingFlags flags);
484 virtual ir::Expression *ParsePrefixAssertionExpression();
485 // NOLINTNEXTLINE(google-default-arguments)
486 virtual ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList(
487 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
488 virtual void ThrowErrorIfStaticConstructor(ir::ModifierFlags flags);
489 virtual std::tuple<bool, bool, bool> ParseComputedClassFieldOrIndexSignature(ir::Expression **propName);
490 // NOLINTNEXTLINE(google-default-arguments)
491 virtual ir::Expression *ParseUnaryOrPrefixUpdateExpression(
492 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
493 // NOLINTNEXTLINE(google-default-arguments)
494 virtual ir::Expression *ParsePrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
495 virtual ir::Expression *ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc,
496 bool ignoreCallExpression, bool *isChainExpression);
497 virtual ir::ClassElement *ParseClassStaticBlock();
498 virtual ParserStatus ValidateArrowParameter(ir::Expression *expr, bool *seenOptional);
499 virtual ArrowFunctionDescriptor ConvertToArrowParameter(ir::Expression *expr, bool isAsync);
500 virtual ir::Expression *ParseNewExpression();
501
502 virtual ir::TSTypeParameterDeclaration *ParseFunctionTypeParameters()
503 {
504 return nullptr;
505 }
506
507 virtual ir::TypeNode *ParseFunctionReturnType([[maybe_unused]] ParserStatus status)
508 {
509 return nullptr;
510 }
511
512 virtual ir::ScriptFunctionFlags ParseFunctionThrowMarker([[maybe_unused]] const bool isRethrowsAllowed)
513 {
514 return ir::ScriptFunctionFlags::NONE;
515 }
516
517 using NodeFormatType = std::pair<char, std::size_t>;
518 // NOLINTNEXTLINE(google-default-arguments)
519 virtual ir::Identifier *ParseIdentifierFormatPlaceholder(
520 [[maybe_unused]] std::optional<NodeFormatType> nodeFormat = std::nullopt)
521 {
522 ThrowSyntaxError("Identifier expected");
523 }
524
525 virtual std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ParseFunctionBody(
526 const ArenaVector<ir::Expression *> ¶ms, ParserStatus newStatus, ParserStatus contextStatus);
527 virtual ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers);
528 virtual ir::Statement *ParseExportDeclaration(StatementParsingFlags flags);
529
530 // NOLINTNEXTLINE(google-default-arguments)
531 virtual ir::ExportDefaultDeclaration *ParseExportDefaultDeclaration(const lexer::SourcePosition &startLoc,
532 bool isExportEquals = false);
533 virtual ir::ExportNamedDeclaration *ParseNamedExportDeclaration(const lexer::SourcePosition &startLoc);
534 virtual void ValidateForInStatement() {};
535 virtual ir::Statement *ParseTryStatement();
536 virtual ir::ThrowStatement *ParseThrowStatement();
537 virtual ir::DebuggerStatement *ParseDebuggerStatement();
538 // NOLINTNEXTLINE(google-default-arguments)
539 virtual ir::Statement *ParseModuleDeclaration(StatementParsingFlags flags = StatementParsingFlags::NONE)
540 {
541 return ParsePotentialExpressionStatement(flags);
542 };
543
544 virtual ir::Statement *ParseInterfaceDeclaration([[maybe_unused]] bool isStatic)
545 {
546 ThrowUnexpectedToken(lexer::TokenType::KEYW_INTERFACE);
547 }
548
549 // NOLINTNEXTLINE(google-default-arguments)
550 virtual ir::Statement *ParseEnumDeclaration([[maybe_unused]] bool isConst = false,
551 [[maybe_unused]] bool isStatic = false)
552 {
553 ThrowUnexpectedToken(lexer::TokenType::KEYW_ENUM);
554 }
555
556 virtual std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseSuperClass();
557 virtual ir::Expression *ParseSuperClassReference();
558
559 using ClassBody = std::tuple<ir::MethodDefinition *, ArenaVector<ir::AstNode *>, lexer::SourceRange>;
560 ClassBody ParseClassBody(ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags = ir::ModifierFlags::NONE,
561 ir::Identifier *identNode = nullptr);
562
563 Program *GetProgram() const
564 {
565 return program_;
566 }
567
568 void SetProgram(Program *program)
569 {
570 program_ = program;
571 }
572
573 lexer::Lexer *Lexer() const
574 {
575 return lexer_;
576 }
577
578 void SetLexer(lexer::Lexer *lexer)
579 {
580 lexer_ = lexer;
581 }
582
583 ParserContext &GetContext()
584 {
585 return context_;
586 }
587
588 const ParserContext &GetContext() const
589 {
590 return context_;
591 }
592
593 const CompilerOptions &GetOptions() const
594 {
595 return options_;
596 }
597
598 uint32_t &ClassId()
599 {
600 return classId_;
601 }
602
603 private:
604 Program *program_;
605 ParserContext context_;
606 ClassPrivateContext classPrivateContext_;
607 uint32_t classId_ {};
608 lexer::Lexer *lexer_ {};
609 const CompilerOptions &options_;
610 };
611
612 template <ParserStatus STATUS>
613 class SavedStatusContext {
614 public:
SavedStatusContext(ParserContext * ctx)615 explicit SavedStatusContext(ParserContext *ctx)
616 // NOLINTNEXTLINE(readability-magic-numbers)
617 : ctx_(ctx), savedStatus_(static_cast<ParserStatus>(ctx->Status() & STATUS))
618 {
619 // NOLINTNEXTLINE(readability-magic-numbers)
620 ctx->Status() |= STATUS;
621 }
622
623 NO_COPY_SEMANTIC(SavedStatusContext);
624 NO_MOVE_SEMANTIC(SavedStatusContext);
625
~SavedStatusContext()626 ~SavedStatusContext()
627 {
628 if (savedStatus_ == ParserStatus::NO_OPTS) {
629 ctx_->Status() &= ~savedStatus_;
630 }
631 }
632
633 private:
634 ParserContext *ctx_;
635 ParserStatus savedStatus_;
636 };
637
638 class SwitchContext : public SavedStatusContext<ParserStatus::IN_SWITCH> {
639 public:
SwitchContext(ParserContext * ctx)640 explicit SwitchContext(ParserContext *ctx) : SavedStatusContext(ctx) {}
641 NO_COPY_SEMANTIC(SwitchContext);
642 NO_MOVE_SEMANTIC(SwitchContext);
643 ~SwitchContext() = default;
644 };
645
646 class IterationContext : public SavedStatusContext<ParserStatus::IN_ITERATION> {
647 public:
IterationContext(ParserContext * ctx)648 explicit IterationContext(ParserContext *ctx) : SavedStatusContext(ctx) {}
649
650 NO_COPY_SEMANTIC(IterationContext);
651 NO_MOVE_SEMANTIC(IterationContext);
652 ~IterationContext() = default;
653 };
654
655 class FunctionParameterContext : public SavedStatusContext<ParserStatus::FUNCTION_PARAM> {
656 public:
FunctionParameterContext(ParserContext * ctx)657 explicit FunctionParameterContext(ParserContext *ctx) : SavedStatusContext(ctx) {}
658
659 NO_COPY_SEMANTIC(FunctionParameterContext);
660 NO_MOVE_SEMANTIC(FunctionParameterContext);
661 ~FunctionParameterContext() = default;
662 };
663
664 class SavedParserContext {
665 public:
666 template <typename... Args>
SavedParserContext(ParserImpl * parser,Args &&...args)667 explicit SavedParserContext(ParserImpl *parser, Args &&...args) : parser_(parser), prev_(parser->context_)
668 {
669 parser_->context_ = ParserContext(&prev_, std::forward<Args>(args)...);
670 }
671
672 NO_COPY_SEMANTIC(SavedParserContext);
673 DEFAULT_MOVE_SEMANTIC(SavedParserContext);
674
~SavedParserContext()675 ~SavedParserContext()
676 {
677 parser_->context_ = prev_;
678 }
679
680 private:
681 ParserImpl *parser_;
682 ParserContext prev_;
683 };
684
685 class SavedClassPrivateContext {
686 public:
SavedClassPrivateContext(ParserImpl * parser)687 explicit SavedClassPrivateContext(ParserImpl *parser) : parser_(parser), prev_(parser->classPrivateContext_)
688 {
689 parser_->classPrivateContext_ = ClassPrivateContext(&prev_);
690 }
691
692 NO_COPY_SEMANTIC(SavedClassPrivateContext);
693 DEFAULT_MOVE_SEMANTIC(SavedClassPrivateContext);
694
~SavedClassPrivateContext()695 ~SavedClassPrivateContext()
696 {
697 parser_->classPrivateContext_ = prev_;
698 }
699
700 private:
701 ParserImpl *parser_;
702 ClassPrivateContext prev_;
703 };
704
705 class FunctionContext : public SavedParserContext {
706 public:
FunctionContext(ParserImpl * parser,ParserStatus newStatus)707 explicit FunctionContext(ParserImpl *parser, ParserStatus newStatus) : SavedParserContext(parser, newStatus)
708 {
709 if ((newStatus & ParserStatus::GENERATOR_FUNCTION) != 0) {
710 flags_ |= ir::ScriptFunctionFlags::GENERATOR;
711 }
712
713 if ((newStatus & ParserStatus::ASYNC_FUNCTION) != 0) {
714 flags_ |= ir::ScriptFunctionFlags::ASYNC;
715 }
716
717 if ((newStatus & ParserStatus::CONSTRUCTOR_FUNCTION) != 0) {
718 flags_ |= ir::ScriptFunctionFlags::CONSTRUCTOR;
719 }
720 }
721
Flags()722 ir::ScriptFunctionFlags Flags() const
723 {
724 return flags_;
725 }
726
AddFlag(ir::ScriptFunctionFlags flags)727 void AddFlag(ir::ScriptFunctionFlags flags)
728 {
729 flags_ |= flags;
730 }
731
732 NO_COPY_SEMANTIC(FunctionContext);
733 NO_MOVE_SEMANTIC(FunctionContext);
734 ~FunctionContext() = default;
735
736 private:
737 ir::ScriptFunctionFlags flags_ {ir::ScriptFunctionFlags::NONE};
738 };
739
740 class ArrowFunctionContext : public FunctionContext {
741 public:
ArrowFunctionContext(ParserImpl * parser,bool isAsync)742 explicit ArrowFunctionContext(ParserImpl *parser, bool isAsync)
743 : FunctionContext(parser, InitialFlags(parser->context_.Status()))
744 {
745 if (isAsync) {
746 AddFlag(ir::ScriptFunctionFlags::ASYNC);
747 }
748
749 AddFlag(ir::ScriptFunctionFlags::ARROW);
750 }
751
752 NO_COPY_SEMANTIC(ArrowFunctionContext);
753 NO_MOVE_SEMANTIC(ArrowFunctionContext);
754 ~ArrowFunctionContext() = default;
755
756 private:
InitialFlags(ParserStatus currentStatus)757 static ParserStatus InitialFlags(ParserStatus currentStatus)
758 {
759 return ParserStatus::FUNCTION | ParserStatus::ARROW_FUNCTION |
760 static_cast<ParserStatus>(currentStatus & (ParserStatus::ALLOW_SUPER | ParserStatus::ALLOW_SUPER_CALL));
761 }
762 };
763 } // namespace panda::es2panda::parser
764 #endif
765