1 /**
2 * Copyright (c) 2021 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 <binder/binder.h>
20 #include <es2panda.h>
21 #include <ir/astNode.h>
22 #include <lexer/token/sourceLocation.h>
23 #include <macros.h>
24 #include <mem/arena_allocator.h>
25 #include <parser/context/parserContext.h>
26 #include <parser/module/sourceTextModuleRecord.h>
27 #include <parser/parserFlags.h>
28 #include <parser/program/program.h>
29 #include <util/enumbitops.h>
30 #include <util/ustring.h>
31
32 #include <memory>
33 #include <sstream>
34 #include <unordered_map>
35 #include <unordered_set>
36
37 namespace panda::es2panda::lexer {
38 enum class TokenFlags;
39 enum class TokenType;
40 class LexerPosition;
41 class Token;
42 class Lexer;
43 } // namespace panda::es2panda::lexer
44
45 namespace panda::es2panda::ir {
46 class ArrowFunctionExpression;
47 class AstNode;
48 class BlockStatement;
49 class BreakStatement;
50 class CallExpression;
51 class ClassDeclaration;
52 class ClassDefinition;
53 class ContinueStatement;
54 class DoWhileStatement;
55 class ExportAllDeclaration;
56 class ExportDefaultDeclaration;
57 class ExportNamedDeclaration;
58 class ExportNamedDeclaration;
59 class Expression;
60 class FunctionDeclaration;
61 class FunctionExpression;
62 class Identifier;
63 class IfStatement;
64 class ImportDeclaration;
65 class LabelledStatement;
66 class NewExpression;
67 class ObjectExpression;
68 class ReturnStatement;
69 class ScriptFunction;
70 class SequenceExpression;
71 class SpreadElement;
72 class Statement;
73 class StringLiteral;
74 class SwitchCaseStatement;
75 class SwitchStatement;
76 class TSArrayType;
77 class TSEnumDeclaration;
78 class TSFunctionType;
79 class TSInterfaceDeclaration;
80 class TSIntersectionType;
81 class TSTupleType;
82 class TSTypeAliasDeclaration;
83 class TSUnionType;
84 class TSImportType;
85 class TemplateLiteral;
86 class ThrowStatement;
87 class TryStatement;
88 class VariableDeclaration;
89 class WhileStatement;
90 class WithStatement;
91 class TSTypeParameter;
92 class TSTypeParameterDeclaration;
93 class MemberExpression;
94 class MethodDefinition;
95 class TSTypeReference;
96 class TSMappedType;
97 class TSTypePredicate;
98 class Decorator;
99 class TSIndexSignature;
100 class Property;
101 class TSTypeParameterInstantiation;
102 class TSParameterProperty;
103 class TSTypeAssertion;
104 class TSAsExpression;
105 class YieldExpression;
106 class MetaProperty;
107 class TSModuleDeclaration;
108 class TSImportEqualsDeclaration;
109 class TSModuleBlock;
110 class EmptyStatement;
111 class DebuggerStatement;
112 class CatchClause;
113 class VariableDeclarator;
114
115 enum class PropertyKind;
116 enum class TSTupleKind;
117 enum class MethodDefinitionKind;
118 enum class ModifierFlags;
119 } // namespace panda::es2panda::ir
120
121 namespace panda::es2panda::parser {
122
123 class Program;
124 class ParserContext;
125
126 class ClassElmentDescriptor {
127 public:
128 ir::MethodDefinitionKind methodKind {};
129 ParserStatus newStatus {};
130 ir::ModifierFlags modifiers {};
131 lexer::SourcePosition methodStart {};
132 lexer::SourcePosition propStart {};
133 bool isPrivateIdent {};
134 bool hasSuperClass {};
135 bool isGenerator {};
136 bool invalidComputedProperty {};
137 bool isComputed {};
138 bool isIndexSignature {};
139 bool classMethod {};
140 bool classField {};
141 };
142
143 class ArrowFunctionDescriptor {
144 public:
ArrowFunctionDescriptor(ArenaVector<ir::Expression * > && p,binder::FunctionParamScope * ps,lexer::SourcePosition sl,ParserStatus ns)145 explicit ArrowFunctionDescriptor(ArenaVector<ir::Expression *> &&p, binder::FunctionParamScope *ps,
146 lexer::SourcePosition sl, ParserStatus ns)
147 : params(p), paramScope(ps), startLoc(sl), newStatus(ns)
148 {
149 }
150
151 ArenaVector<ir::Expression *> params;
152 binder::FunctionParamScope *paramScope;
153 lexer::SourcePosition startLoc;
154 ParserStatus newStatus;
155 };
156
157 enum class TypeAnnotationParsingOptions {
158 NO_OPTS = 0,
159 IN_UNION = 1 << 0,
160 ALLOW_CONST = 1 << 1,
161 IN_INTERSECTION = 1 << 2,
162 RESTRICT_EXTENDS = 1 << 3,
163 THROW_ERROR = 1 << 4,
164 CAN_BE_TS_TYPE_PREDICATE = 1 << 5,
165 BREAK_AT_NEW_LINE = 1 << 6,
166 IN_MODIFIER = 1 << 7,
167 };
168
DEFINE_BITOPS(TypeAnnotationParsingOptions)169 DEFINE_BITOPS(TypeAnnotationParsingOptions)
170
171 class ArrowFunctionContext;
172
173 class ParserImpl {
174 public:
175 explicit ParserImpl(es2panda::ScriptExtension extension);
176 NO_COPY_SEMANTIC(ParserImpl);
177 NO_MOVE_SEMANTIC(ParserImpl);
178 ~ParserImpl() = default;
179
180 Program Parse(const std::string &fileName, const std::string &source,
181 const std::string &recordName, ScriptKind kind);
182
183 ScriptExtension Extension() const;
184
185 void AddHotfixHelper(util::Hotfix *hotfixHelper);
186
187 ArenaAllocator *Allocator() const
188 {
189 return program_.Allocator();
190 }
191
192 private:
193 bool IsStartOfMappedType() const;
194 bool IsStartOfTsTypePredicate() const;
195 bool IsStartOfAbstractConstructorType() const;
196
197 bool CurrentTokenIsModifier(char32_t nextCp) const;
198 [[noreturn]] void ThrowParameterModifierError(ir::ModifierFlags status) const;
199 [[noreturn]] void ThrowSyntaxError(std::string_view errorMessage) const;
200 [[noreturn]] void ThrowSyntaxError(std::initializer_list<std::string_view> list) const;
201 [[noreturn]] void ThrowSyntaxError(std::initializer_list<std::string_view> list,
202 const lexer::SourcePosition &pos) const;
203
204 [[noreturn]] void ThrowSyntaxError(std::string_view errorMessage, const lexer::SourcePosition &pos) const;
205
206 template <typename T, typename... Args>
207 T *AllocNode(Args &&... args)
208 {
209 auto ret = program_.Allocator()->New<T>(std::forward<Args>(args)...);
210 if (ret == nullptr) {
211 throw Error(ErrorType::GENERIC, "Unsuccessful allocation during parsing");
212 }
213 return ret;
214 }
215
216 [[nodiscard]] std::unique_ptr<lexer::Lexer> InitLexer(const std::string &fileName, const std::string &source);
217 void ParseScript();
218 void ParseModule();
219
220 /*
221 * Transform the commonjs module's AST by wrap the sourceCode & use Reflect.apply to invoke this wrapper with [this]
222 * pointing to [exports] object
223 *
224 * Reflect.apply(function (exports, require, module, __filename, __dirname) {
225 * [SourceCode]
226 * }, exports, [exports, require, module, __filename, __dirname]);
227 */
228 void ParseCommonjs();
229 void AddCommonjsParams(ArenaVector<ir::Expression *> ¶ms);
230 void AddReflectApplyArgs(ArenaVector<ir::Expression *> &args, ir::FunctionExpression *wrapper);
231 void ParseProgram(ScriptKind kind);
232 static ExpressionParseFlags CarryExpressionParserFlag(ExpressionParseFlags origin, ExpressionParseFlags carry);
233 static ExpressionParseFlags CarryPatternFlags(ExpressionParseFlags flags);
234 bool CurrentIsBasicType();
235 bool CurrentLiteralIsBasicType();
236 static bool CheckTypeNameIsReserved(const util::StringView ¶mName);
237 static bool IsPropertyKeysAreSame(const ir::Expression *exp1, const ir::Expression *exp2);
238 static bool IsMemberExpressionsAreSame(const ir::MemberExpression *mExp1, const ir::MemberExpression *mExp2);
239 static bool IsMethodDefinitionsAreSame(const ir::MethodDefinition *property, ir::MethodDefinition *overload);
240 ir::TSTypeReference *ParseTsConstExpression();
241 ir::Expression *ParseTsTypeOperatorOrTypeReference();
242 ir::Expression *ParseTsIdentifierReference();
243 ir::Expression *ParseTsBasicType();
244 ir::TSIntersectionType *ParseTsIntersectionType(ir::Expression *type, bool inUnion, bool restrictExtends);
245 ir::TSUnionType *ParseTsUnionType(ir::Expression *type, bool restrictExtends);
246 ir::Expression *ParseTsParenthesizedOrFunctionType(ir::Expression *typeAnnotation, bool throwError);
247 ir::TSArrayType *ParseTsArrayType(ir::Expression *elementType);
248 ir::Expression *ParseTsFunctionType(lexer::SourcePosition startLoc, bool isConstructionType, bool throwError,
249 bool abstractConstructor = false);
250 ir::TSTypeParameter *ParseTsMappedTypeParameter();
251 ir::MappedOption ParseMappedOption(lexer::TokenType tokenType);
252 ir::TSMappedType *ParseTsMappedType();
253 ir::TSTypePredicate *ParseTsTypePredicate();
254 ir::Expression *ParseTsTypeLiteralOrInterfaceKey(bool *computed, bool *signature, bool *isIndexSignature);
255 ir::Expression *ParseTsConditionalType(ir::Expression *checkType, bool restrictExtends);
256 ir::Expression *ParseTsTypeLiteralOrInterfaceMember();
257 ArenaVector<ir::Expression *> ParseTsTypeLiteralOrInterface();
258 ir::Expression *ParseTsThisType(bool throwError);
259 ir::Expression *ParseTsIndexAccessType(ir::Expression *typeName);
260 ir::Expression *ParseTsQualifiedReference(ir::Expression *typeName);
261 ir::Expression *ParseTsTypeReferenceOrQuery(bool parseQuery = false);
262 bool IsTSNamedTupleMember();
263 ir::Expression *ParseTsTupleElement(ir::TSTupleKind *kind, bool *seenOptional);
264 ir::TSTupleType *ParseTsTupleType();
265 ir::TSImportType *ParseTsImportType(const lexer::SourcePosition &startLoc, bool isTypeof = false);
266 ir::Expression *ParseTsTypeAnnotation(TypeAnnotationParsingOptions *options);
267 ir::Expression *ParseTsTypeLiteralOrTsMappedType(ir::Expression *typeAnnotation);
268 ir::Expression *ParseTsTypeReferenceOrTsTypePredicate(ir::Expression *typeAnnotation, bool canBeTsTypePredicate);
269 ir::Expression *ParseTsThisTypeOrTsTypePredicate(ir::Expression *typeAnnotation, bool canBeTsTypePredicate,
270 bool throwError);
271 ir::Expression *ParseTsTemplateLiteralType();
272 ir::Expression *ParseTsTypeAnnotationElement(ir::Expression *typeAnnotation, TypeAnnotationParsingOptions *options);
273 ir::ModifierFlags ParseModifiers();
274
275 void ThrowIfPrivateIdent(ClassElmentDescriptor *desc, const char *msg);
276 void ValidateClassKey(ClassElmentDescriptor *desc, bool isDeclare);
277
278 void ValidateClassMethodStart(ClassElmentDescriptor *desc, ir::Expression *typeAnnotation);
279 ir::Expression *ParseClassKey(ClassElmentDescriptor *desc, bool isDeclare);
280
281 void ValidateClassSetter(ClassElmentDescriptor *desc, const ArenaVector<ir::Statement *> &properties,
282 ir::Expression *propName, ir::ScriptFunction *func, bool hasDecorator,
283 lexer::SourcePosition errorInfo);
284 void ValidateClassGetter(ClassElmentDescriptor *desc, const ArenaVector<ir::Statement *> &properties,
285 ir::Expression *propName, ir::ScriptFunction *func, bool hasDecorator,
286 lexer::SourcePosition errorInfo);
287 ir::MethodDefinition *ParseClassMethod(ClassElmentDescriptor *desc, const ArenaVector<ir::Statement *> &properties,
288 ir::Expression *propName, lexer::SourcePosition *propEnd,
289 ArenaVector<ir::Decorator *> &&decorators, bool isDeclare);
290 ir::Statement *ParseClassProperty(ClassElmentDescriptor *desc, const ArenaVector<ir::Statement *> &properties,
291 ir::Expression *propName, ir::Expression *typeAnnotation,
292 ArenaVector<ir::Decorator *> &&decorators, bool isDeclare);
293 void ParseClassKeyModifiers(ClassElmentDescriptor *desc);
294 void CheckClassGeneratorMethod(ClassElmentDescriptor *desc);
295 void CheckClassPrivateIdentifier(ClassElmentDescriptor *desc);
296 ir::Expression *ParseClassKeyAnnotation();
297 ir::Decorator *ParseDecorator();
298 ArenaVector<ir::Decorator *> ParseDecorators();
299 ir::Statement *ParseClassElement(const ArenaVector<ir::Statement *> &properties,
300 ArenaVector<ir::TSIndexSignature *> *indexSignatures, bool hasSuperClass,
301 bool isDeclare, bool isAbstractClass);
302 ir::MethodDefinition *CreateImplicitConstructor(bool hasSuperClass, bool isDeclare = false);
303 ir::MethodDefinition *CheckClassMethodOverload(ir::Statement *property, ir::MethodDefinition **ctor, bool isDeclare,
304 lexer::SourcePosition errorInfo, ir::MethodDefinition *lastOverload,
305 bool implExists, bool isAbstract = false);
306 ir::Identifier *SetIdentNodeInClassDefinition();
307 ir::ClassDefinition *ParseClassDefinition(bool isDeclaration, bool idRequired = true, bool isDeclare = false,
308 bool isAbstract = false);
309
310 void ValidateAccessor(ExpressionParseFlags flags, lexer::TokenFlags currentTokenFlags);
311 void CheckPropertyKeyAsycModifier(ParserStatus *methodStatus);
312 ir::Property *ParseShorthandProperty(const lexer::LexerPosition *startPos);
313 void ParseGeneratorPropertyModifier(ExpressionParseFlags flags, ParserStatus *methodStatus);
314 bool ParsePropertyModifiers(ExpressionParseFlags flags, ir::PropertyKind *propertyKind, ParserStatus *methodStatus);
315 ir::Expression *ParsePropertyKey(ExpressionParseFlags flags);
316 ir::Expression *ParsePropertyValue(const ir::PropertyKind *propertyKind, const ParserStatus *methodStatus,
317 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
318 bool ParsePropertyEnd();
319
320 ir::Expression *ParsePropertyDefinition(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
321 ir::TSTypeParameter *ParseTsTypeParameter(bool throwError, bool addBinding = false);
322 ir::TSTypeParameterDeclaration *ParseTsTypeParameterDeclaration(bool throwError = true);
323 ir::TSTypeParameterInstantiation *ParseTsTypeParameterInstantiation(bool throwError = true);
324 ir::ScriptFunction *ParseFunction(ParserStatus newStatus = ParserStatus::NO_OPTS, bool isDeclare = false);
325 void ValidateFunctionParam(const ArenaVector<ir::Expression *> ¶ms, const ir::Expression *parameter,
326 bool *seenOptional);
327 void ValidateTsFunctionOverloadParams(const ArenaVector<ir::Expression *> ¶ms);
328 void CheckAccessorPair(const ArenaVector<ir::Statement *> &properties, const ir::Expression *propName,
329 ir::MethodDefinitionKind methodKind, ir::ModifierFlags access, bool hasDecorator,
330 lexer::SourcePosition errorInfo);
331 ArenaVector<ir::Expression *> ParseFunctionParams(bool isDeclare = false);
332 ir::SpreadElement *ParseSpreadElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
333 ir::TSParameterProperty *CreateTsParameterProperty(ir::Expression *parameter, ir::ModifierFlags modifiers);
334 ir::Expression *ParseFunctionParameter(bool isDeclare);
335 void CreateTSVariableForProperty(ir::AstNode *node, const ir::Expression *key, binder::VariableFlags flags);
336 void CheckObjectTypeForDuplicatedProperties(ir::Expression *member, ArenaVector<ir::Expression *> const &members);
337
338 // ExpressionParser.Cpp
339
340 ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
341 ir::ArrowFunctionExpression *ParseTsGenericArrowFunction();
342 ir::TSTypeAssertion *ParseTsTypeAssertion(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
343 ir::TSAsExpression *ParseTsAsExpression(ir::Expression *expr, ExpressionParseFlags flags);
344 ir::Expression *ParseArrayExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
345 ir::YieldExpression *ParseYieldExpression();
346 ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags);
347 ParserStatus ValidateArrowParameter(ir::Expression *expr);
348
349 ArrowFunctionDescriptor ConvertToArrowParameter(ir::Expression *expr, bool isAsync,
350 binder::FunctionParamScope *paramScope);
351 ir::ArrowFunctionExpression *ParseArrowFunctionExpressionBody(ArrowFunctionContext *arrowFunctionContext,
352 binder::FunctionScope *functionScope,
353 ArrowFunctionDescriptor *desc,
354 ir::TSTypeParameterDeclaration *typeParamDecl,
355 ir::Expression *returnTypeAnnotation);
356 ir::ArrowFunctionExpression *ParseArrowFunctionExpression(ir::Expression *expr,
357 ir::TSTypeParameterDeclaration *typeParamDecl,
358 ir::Expression *returnTypeAnnotation, bool isAsync);
359 ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList();
360 ir::Expression *ParseKeywordExpression();
361 ir::Expression *ParseBinaryExpression(ir::Expression *left);
362 ir::CallExpression *ParseCallExpression(ir::Expression *callee, bool isOptionalChain = false, bool isAsync = false);
363 ir::ArrowFunctionExpression *ParsePotentialArrowExpression(ir::Expression **returnExpression,
364 const lexer::SourcePosition &startLoc);
365
366 void ValidateUpdateExpression(ir::Expression *returnExpression, bool isChainExpression);
367 bool ParsePotentialTsGenericFunctionCall(ir::Expression **returnExpression, const lexer::SourcePosition &startLoc,
368 bool ignoreCallExpression);
369 ir::Expression *ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc,
370 bool ignoreCallExpression, bool *isChainExpression);
371 ir::Expression *ParseMemberExpression(bool ignoreCallExpression = false,
372 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
373 ir::ObjectExpression *ParseObjectExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
374 ir::SequenceExpression *ParseSequenceExpression(ir::Expression *startExpr, bool acceptRest = false,
375 bool acceptTsParam = false);
376 ir::Expression *ParseUnaryOrPrefixUpdateExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
377 ir::Expression *ParseLeftHandSideExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
378 ir::MetaProperty *ParsePotentialNewTarget();
379 void CheckInvalidDestructuring(const ir::AstNode *object) const;
380 void ValidateParenthesizedExpression(ir::Expression *lhsExpression);
381 ir::Expression *ParseAssignmentExpression(ir::Expression *lhsExpression,
382 ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
383 ir::Expression *ParsePrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
384 ir::NewExpression *ParseNewExpression();
385 void ParsePotentialTsFunctionParameter(ExpressionParseFlags flags, ir::Expression *returnNode,
386 bool isDeclare = false);
387 ir::Expression *ParsePatternElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS,
388 bool allowDefault = true, bool isDeclare = false);
389 ir::TemplateLiteral *ParseTemplateLiteral();
390 ir::Expression *ParseImportExpression();
391 ir::FunctionExpression *ParseFunctionExpression(ParserStatus newStatus = ParserStatus::NO_OPTS);
392 ir::Expression *ParseOptionalChain(ir::Expression *leftSideExpr);
393 void ParseNameSpaceImport(ArenaVector<ir::AstNode *> *specifiers);
394 ir::Identifier *ParseNamedImport(const lexer::Token &importedToken);
395
396 ir::StringLiteral *ParseFromClause(bool requireFrom = true);
397 void ParseNamedImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
398 ir::Expression *ParseModuleReference();
399 ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers);
400 ir::AstNode *ParseImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
401 void ValidateAssignmentTarget(ExpressionParseFlags flags, ir::Expression *node);
402 void ValidateLvalueAssignmentTarget(ir::Expression *node);
403 void ValidateArrowParameterBindings(const ir::Expression *node);
404
405 ir::ExportDefaultDeclaration *ParseExportDefaultDeclaration(const lexer::SourcePosition &startLoc,
406 ArenaVector<ir::Decorator *> decorators,
407 bool isExportEquals = false);
408 ir::ExportAllDeclaration *ParseExportAllDeclaration(const lexer::SourcePosition &startLoc);
409 ir::ExportNamedDeclaration *ParseExportNamedSpecifiers(const lexer::SourcePosition &startLoc);
410 ir::ExportNamedDeclaration *ParseNamedExportDeclaration(const lexer::SourcePosition &startLoc,
411 ArenaVector<ir::Decorator *> &&decorators);
412 ir::Identifier *ParseNamedExport(const lexer::Token &exportedToken);
413 void CheckStrictReservedWord() const;
414
415 // StatementParser.Cpp
416
417 void ConsumeSemicolon(ir::Statement *statement);
418 void CheckFunctionDeclaration(StatementParsingFlags flags);
419
420 void CheckLabelledFunction(const ir::Statement *node);
421 void CheckDeclare();
422
423 bool IsLabelFollowedByIterationStatement();
424
425 void AddImportEntryItem(const ir::StringLiteral *source, const ArenaVector<ir::AstNode *> *specifiers);
426 void AddExportNamedEntryItem(const ArenaVector<ir::ExportSpecifier *> &specifiers, const ir::StringLiteral *source);
427 void AddExportStarEntryItem(const lexer::SourcePosition &startLoc, const ir::StringLiteral *source,
428 const ir::Identifier *exported);
429 void AddExportDefaultEntryItem(const ir::AstNode *declNode);
430 void AddExportLocalEntryItem(const ir::Statement *declNode, bool isTsModule);
431 parser::SourceTextModuleRecord *GetSourceTextModuleRecord();
432
433 bool ParseDirective(ArenaVector<ir::Statement *> *statements);
434 void ParseDirectivePrologue(ArenaVector<ir::Statement *> *statements);
435 ArenaVector<ir::Statement *> ParseStatementList(StatementParsingFlags flags = StatementParsingFlags::ALLOW_LEXICAL);
436 ir::Statement *ParseStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
437 ir::TSModuleDeclaration *ParseTsModuleDeclaration(bool isDeclare, bool isExport = false);
438 ir::TSModuleDeclaration *ParseTsAmbientExternalModuleDeclaration(const lexer::SourcePosition &startLoc,
439 bool isDeclare);
440 ir::TSModuleDeclaration *ParseTsModuleOrNamespaceDelaration(const lexer::SourcePosition &startLoc,
441 bool isDeclare,
442 bool isExport);
443
444 ir::TSImportEqualsDeclaration *ParseTsImportEqualsDeclaration(const lexer::SourcePosition &startLoc,
445 bool isExport = false);
446 ir::TSModuleBlock *ParseTsModuleBlock();
447 ir::BlockStatement *ParseFunctionBody();
448 ir::BlockStatement *ParseBlockStatement();
449 ir::BlockStatement *ParseBlockStatement(binder::Scope *scope);
450 ir::EmptyStatement *ParseEmptyStatement();
451 ir::DebuggerStatement *ParseDebuggerStatement();
452 ir::BreakStatement *ParseBreakStatement();
453 ir::ContinueStatement *ParseContinueStatement();
454 ir::DoWhileStatement *ParseDoWhileStatement();
455 ir::Statement *ParsePotentialExpressionStatement(StatementParsingFlags flags, bool isDeclare);
456 ir::Statement *ParseVarStatement(bool isDeclare);
457 ir::Statement *ParseLetStatement(StatementParsingFlags flags, bool isDeclare);
458 ir::Statement *ParseConstStatement(StatementParsingFlags flags, bool isDeclare);
459 ir::Statement *ParseExpressionStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
460 ir::Statement *ParseFunctionStatement(StatementParsingFlags flags, bool isDeclare);
461 ir::FunctionDeclaration *ParseFunctionDeclaration(bool canBeAnonymous = false,
462 ParserStatus newStatus = ParserStatus::NO_OPTS,
463 bool isDeclare = false);
464 ir::Statement *ParseExportDeclaration(StatementParsingFlags flags, ArenaVector<ir::Decorator *> &&decorators);
465 std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *> ParseForInOf(
466 ir::Expression *leftNode, ExpressionParseFlags exprFlags, bool isAwait);
467 std::tuple<ForStatementKind, ir::Expression *, ir::Expression *> ParseForInOf(ir::AstNode *initNode,
468 ExpressionParseFlags exprFlags,
469 bool isAwait);
470 std::tuple<ir::Expression *, ir::Expression *> ParseForUpdate(bool isAwait);
471 ir::Statement *ParseForStatement();
472 ir::IfStatement *ParseIfStatement();
473
474 ir::Statement *ParseImportDeclaration(StatementParsingFlags flags);
475 ir::LabelledStatement *ParseLabelledStatement(const lexer::LexerPosition &pos);
476 ir::ReturnStatement *ParseReturnStatement();
477 ir::ClassDeclaration *ParseClassStatement(StatementParsingFlags flags, bool isDeclare,
478 ArenaVector<ir::Decorator *> &&decorators, bool isAbstract = false);
479 ir::ClassDeclaration *ParseClassDeclaration(bool idRequired, ArenaVector<ir::Decorator *> &&decorators,
480 bool isDeclare = false, bool isAbstract = false,
481 bool isExported = false);
482 ir::TSTypeAliasDeclaration *ParseTsTypeAliasDeclaration(bool isDeclare);
483 ir::TSEnumDeclaration *ParseEnumMembers(ir::Identifier *key, const lexer::SourcePosition &enumStart, bool isConst);
484 ir::TSEnumDeclaration *ParseEnumDeclaration(bool isConst = false);
485 ir::TSInterfaceDeclaration *ParseTsInterfaceDeclaration();
486 ir::SwitchCaseStatement *ParseSwitchCaseStatement(bool *seenDefault);
487 ir::SwitchStatement *ParseSwitchStatement();
488 ir::ThrowStatement *ParseThrowStatement();
489 ir::Expression *ParseCatchParam();
490 ir::CatchClause *ParseCatchClause();
491 ir::TryStatement *ParseTryStatement();
492 void ValidateDeclaratorId();
493 ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags,
494 const lexer::SourcePosition &startLoc, bool isDeclare);
495 ir::VariableDeclarator *ParseVariableDeclarator(VariableParsingFlags flags, bool isDeclare);
496 ir::Statement *ParseVariableDeclaration(VariableParsingFlags flags = VariableParsingFlags::NO_OPTS,
497 bool isDeclare = false);
498 ir::WhileStatement *ParseWhileStatement();
499 ir::VariableDeclaration *ParseContextualLet(VariableParsingFlags flags,
500 StatementParsingFlags stmFlags = StatementParsingFlags::ALLOW_LEXICAL,
501 bool isDeclare = false);
502
503 util::StringView GetNamespaceExportInternalName()
504 {
505 std::string name = std::string(parser::SourceTextModuleRecord::ANONY_NAMESPACE_NAME) +
506 std::to_string(namespaceExportCount_++);
507 util::UString internalName(name, Allocator());
508 return internalName.View();
509 }
510
511 binder::Binder *Binder()
512 {
513 return program_.Binder();
514 }
515
516 friend class Lexer;
517 friend class SavedParserContext;
518 friend class ArrowFunctionContext;
519
520 Program program_;
521 ParserContext context_;
522 lexer::Lexer *lexer_ {nullptr};
523 size_t namespaceExportCount_ {0};
524 };
525
526 template <ParserStatus status>
527 class SavedStatusContext {
528 public:
SavedStatusContext(ParserContext * ctx)529 explicit SavedStatusContext(ParserContext *ctx)
530 // NOLINTNEXTLINE(readability-magic-numbers)
531 : ctx_(ctx), savedStatus_(static_cast<ParserStatus>(ctx->Status()))
532 {
533 // NOLINTNEXTLINE(readability-magic-numbers)
534 ctx->Status() |= status;
535 }
536
537 NO_COPY_SEMANTIC(SavedStatusContext);
538 NO_MOVE_SEMANTIC(SavedStatusContext);
539
~SavedStatusContext()540 ~SavedStatusContext()
541 {
542 ctx_->Status() = savedStatus_;
543 }
544
545 private:
546 ParserContext *ctx_;
547 ParserStatus savedStatus_;
548 };
549
550 class SwitchContext : public SavedStatusContext<ParserStatus::IN_SWITCH> {
551 public:
SwitchContext(ParserContext * ctx)552 explicit SwitchContext(ParserContext *ctx) : SavedStatusContext(ctx) {}
553 NO_COPY_SEMANTIC(SwitchContext);
554 NO_MOVE_SEMANTIC(SwitchContext);
555 ~SwitchContext() = default;
556 };
557
558 template <typename T>
559 class IterationContext : public SavedStatusContext<ParserStatus::IN_ITERATION> {
560 public:
IterationContext(ParserContext * ctx,binder::Binder * binder)561 explicit IterationContext(ParserContext *ctx, binder::Binder *binder)
562 : SavedStatusContext(ctx), lexicalScope_(binder)
563 {
564 }
565
566 NO_COPY_SEMANTIC(IterationContext);
567 NO_MOVE_SEMANTIC(IterationContext);
568 ~IterationContext() = default;
569
LexicalScope()570 const auto &LexicalScope() const
571 {
572 return lexicalScope_;
573 }
574
575 private:
576 binder::LexicalScope<T> lexicalScope_;
577 };
578
579 class FunctionParameterContext : public SavedStatusContext<ParserStatus::FUNCTION_PARAM> {
580 public:
FunctionParameterContext(ParserContext * ctx,binder::Binder * binder)581 explicit FunctionParameterContext(ParserContext *ctx, binder::Binder *binder)
582 : SavedStatusContext(ctx), lexicalScope_(binder)
583 {
584 }
585
LexicalScope()586 const auto &LexicalScope() const
587 {
588 return lexicalScope_;
589 }
590
591 NO_COPY_SEMANTIC(FunctionParameterContext);
592 NO_MOVE_SEMANTIC(FunctionParameterContext);
593 ~FunctionParameterContext() = default;
594
595 private:
596 binder::LexicalScope<binder::FunctionParamScope> lexicalScope_;
597 };
598
599 class SavedParserContext {
600 public:
601 template <typename... Args>
SavedParserContext(ParserImpl * parser,Args &&...args)602 explicit SavedParserContext(ParserImpl *parser, Args &&... args) : parser_(parser), prev_(parser->context_)
603 {
604 parser_->context_ = ParserContext(&prev_, std::forward<Args>(args)...);
605 }
606
607 NO_COPY_SEMANTIC(SavedParserContext);
608 DEFAULT_MOVE_SEMANTIC(SavedParserContext);
609
~SavedParserContext()610 ~SavedParserContext()
611 {
612 parser_->context_ = prev_;
613 }
614
615 protected:
Binder()616 binder::Binder *Binder()
617 {
618 return parser_->Binder();
619 }
620
621 ParserImpl *parser_;
622 ParserContext prev_;
623 };
624
625 class FunctionContext : public SavedParserContext {
626 public:
FunctionContext(ParserImpl * parser,ParserStatus newStatus)627 explicit FunctionContext(ParserImpl *parser, ParserStatus newStatus) : SavedParserContext(parser, newStatus)
628 {
629 if (newStatus & ParserStatus::GENERATOR_FUNCTION) {
630 flags_ |= ir::ScriptFunctionFlags::GENERATOR;
631 }
632
633 if (newStatus & ParserStatus::ASYNC_FUNCTION) {
634 flags_ |= ir::ScriptFunctionFlags::ASYNC;
635 }
636
637 if (newStatus & ParserStatus::CONSTRUCTOR_FUNCTION) {
638 flags_ |= ir::ScriptFunctionFlags::CONSTRUCTOR;
639 }
640 }
641
Flags()642 ir::ScriptFunctionFlags Flags() const
643 {
644 return flags_;
645 }
646
AddFlag(ir::ScriptFunctionFlags flags)647 void AddFlag(ir::ScriptFunctionFlags flags)
648 {
649 flags_ |= flags;
650 }
651
652 NO_COPY_SEMANTIC(FunctionContext);
653 NO_MOVE_SEMANTIC(FunctionContext);
654 ~FunctionContext() = default;
655
656 protected:
657 ir::ScriptFunctionFlags flags_ {ir::ScriptFunctionFlags::NONE};
658 };
659
660 class ArrowFunctionContext : public FunctionContext {
661 public:
ArrowFunctionContext(ParserImpl * parser,bool isAsync)662 explicit ArrowFunctionContext(ParserImpl *parser, bool isAsync)
663 : FunctionContext(parser, InitialFlags(parser->context_.Status()))
664 {
665 if (isAsync) {
666 AddFlag(ir::ScriptFunctionFlags::ASYNC);
667 }
668
669 AddFlag(ir::ScriptFunctionFlags::ARROW);
670 }
671
672 NO_COPY_SEMANTIC(ArrowFunctionContext);
673 NO_MOVE_SEMANTIC(ArrowFunctionContext);
674 ~ArrowFunctionContext() = default;
675
676 private:
InitialFlags(ParserStatus currentStatus)677 static ParserStatus InitialFlags(ParserStatus currentStatus)
678 {
679 return ParserStatus::FUNCTION | ParserStatus::ARROW_FUNCTION |
680 static_cast<ParserStatus>(currentStatus & (ParserStatus::ALLOW_SUPER | ParserStatus::ALLOW_SUPER_CALL));
681 }
682 };
683
684 } // namespace panda::es2panda::parser
685
686 #endif
687