Lines Matching refs:ir
21 #include "ir/base/scriptFunctionSignature.h"
104 static ir::VariableDeclaratorFlag GetFlag(VariableParsingFlags flags);
110 ir::Property *ParseShorthandProperty(const lexer::LexerPosition *startPos);
112 bool ParsePropertyModifiers(ExpressionParseFlags flags, ir::PropertyKind *propertyKind, ParserStatus *methodStatus);
113 ir::Expression *ParsePropertyValue(const ir::PropertyKind *propertyKind, const ParserStatus *methodStatus,
119 ir::Expression *ParseKeywordExpression();
120 ir::Expression *ParseBinaryExpression(ir::Expression *left,
122 void ValidateUpdateExpression(ir::Expression *returnExpression, bool isChainExpression);
123 ir::Expression *ParseMemberExpression(bool ignoreCallExpression = false,
125 ir::Expression *SetupChainExpr(ir::Expression *const top, lexer::SourcePosition startLoc);
126 ir::MetaProperty *ParsePotentialNewTarget();
127 void CheckInvalidDestructuring(const ir::AstNode *object) const;
128 void ValidateParenthesizedExpression(ir::Expression *lhsExpression);
129 void ValidateGroupedExpression(ir::Expression *lhsExpression);
130 ir::Expression *ParseImportExpression();
131 ir::Expression *ParseOptionalChain(ir::Expression *leftSideExpr);
132 ir::Expression *ParsePropertyKey(ExpressionParseFlags flags);
133 void ValidateAssignmentTarget(ExpressionParseFlags flags, ir::Expression *node);
134 void ValidateLvalueAssignmentTarget(ir::Expression *node);
135 void ValidateArrowParameterBindings(const ir::Expression *node);
136 ir::Identifier *ParseNamedExport(const lexer::Token &exportedToken);
137 virtual void ParseTrailingBlock([[maybe_unused]] ir::CallExpression *callExpr) {}
142 void CheckLabelledFunction(const ir::Statement *node);
143 bool ParseDirective(ArenaVector<ir::Statement *> *statements);
144 void ParseDirectivePrologue(ArenaVector<ir::Statement *> *statements);
145 ir::BlockStatement *ParseFunctionBody();
146 std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *> ParseIsForInOf(
147 ir::Expression *leftNode, ExpressionParseFlags exprFlags);
148 std::tuple<ForStatementKind, ir::AstNode *, ir::Expression *, ir::Expression *> ParseForInOf(
149 ir::Expression *leftNode, ExpressionParseFlags exprFlags, bool isAwait);
150 std::tuple<ForStatementKind, ir::Expression *, ir::Expression *> ParseForInOf(ir::AstNode *initNode,
153 std::tuple<ir::Expression *, ir::Expression *> ParseForUpdate(bool isAwait);
154 std::tuple<ir::Expression *, ir::AstNode *> ParseForLoopInitializer();
155 ir::SwitchCaseStatement *ParseSwitchCaseStatement(bool *seenDefault);
156 virtual ir::Expression *ParseCatchParam();
157 ir::CatchClause *ParseCatchClause();
158 ir::VariableDeclaration *ParseContextualLet(VariableParsingFlags flags,
168 [[noreturn]] void ThrowParameterModifierError(ir::ModifierFlags status) const;
205 ir::Identifier *ExpectIdentifier(bool isReference = false, bool isUserDefinedType = false);
210 ir::SpreadElement *ParseSpreadElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
211 ir::YieldExpression *ParseYieldExpression();
212 virtual ir::Expression *ParsePotentialExpressionSequence(ir::Expression *expr, ExpressionParseFlags flags);
213 ir::ArrowFunctionExpression *ParseArrowFunctionExpressionBody(ArrowFunctionContext *arrowFunctionContext,
215 ir::TSTypeParameterDeclaration *typeParamDecl,
216 ir::TypeNode *returnTypeAnnotation);
217 ir::Expression *ParseAssignmentExpression(ir::Expression *lhsExpression,
219 ir::Expression *ParseAssignmentBinaryExpression(lexer::TokenType tokenType, ir::Expression *lhsExpression,
221 ir::Expression *ParseAssignmentEqualExpression(lexer::TokenType tokenType, ir::Expression *lhsExpression,
223 ir::SequenceExpression *ParseSequenceExpression(ir::Expression *startExpr, bool acceptRest = false);
224 ir::FunctionExpression *ParseFunctionExpression(ParserStatus newStatus = ParserStatus::NO_OPTS);
225 ir::ArrowFunctionExpression *ParseArrowFunctionExpression(ir::Expression *expr,
226 ir::TSTypeParameterDeclaration *typeParamDecl,
227 ir::TypeNode *returnTypeAnnotation, bool isAsync);
228 ir::CallExpression *ParseCallExpression(ir::Expression *callee, bool isOptionalChain = false,
230 ArenaVector<ir::Expression *> ParseCallExpressionArguments(bool &trailingComma);
232 ir::TemplateLiteral *ParseTemplateLiteral();
233 ir::Expression *ParseLeftHandSideExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
234 void ParseNameSpaceImport(ArenaVector<ir::AstNode *> *specifiers);
235 void ParseNamedImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
236 ir::StringLiteral *ParseFromClause(bool requireFrom = true);
238 ir::BooleanLiteral *ParseBooleanLiteral();
239 ir::NullLiteral *ParseNullLiteral();
240 ir::Literal *ParseNumberLiteral();
241 ir::CharLiteral *ParseCharLiteral();
242 ir::StringLiteral *ParseStringLiteral();
243 ir::UndefinedLiteral *ParseUndefinedLiteral();
244 virtual ir::ThisExpression *ParseThisExpression();
245 ir::RegExpLiteral *ParseRegularExpression();
246 ir::SuperExpression *ParseSuperExpression();
247 ir::MemberExpression *ParseElementAccess(ir::Expression *primaryExpr, bool isOptional = false);
248 ir::MemberExpression *ParsePrivatePropertyAccess(ir::Expression *primaryExpr);
249 ir::MemberExpression *ParsePropertyAccess(ir::Expression *primaryExpr, bool isOptional = false);
250 void CreateAmendedBinaryExpression(ir::Expression *left, ir::Expression *right, lexer::TokenType operatorType);
253 ArenaVector<ir::Statement *> ParseStatementList(StatementParsingFlags flags = StatementParsingFlags::ALLOW_LEXICAL);
254 virtual ir::Statement *ParseAssertStatement();
256 ir::BlockStatement *ParseBlockStatement();
257 ir::EmptyStatement *ParseEmptyStatement();
258 ir::Statement *ParseForStatement();
259 ir::IfStatement *ParseIfStatement();
260 virtual ir::Statement *ParseFunctionStatement(StatementParsingFlags flags);
262 virtual ir::ClassDeclaration *ParseClassStatement(StatementParsingFlags flags,
263 ir::ClassDefinitionModifiers modifiers,
264 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE);
266 virtual ir::ETSStructDeclaration *ParseStructStatement(StatementParsingFlags flags,
267 ir::ClassDefinitionModifiers modifiers,
268 ir::ModifierFlags modFlags = ir::ModifierFlags::NONE);
269 ir::Statement *ParseVarStatement();
270 ir::Statement *ParseLetStatement(StatementParsingFlags flags);
271 ir::BreakStatement *ParseBreakStatement();
272 ir::ContinueStatement *ParseContinueStatement();
273 ir::DoWhileStatement *ParseDoWhileStatement();
274 ir::WhileStatement *ParseWhileStatement();
275 ir::SwitchStatement *ParseSwitchStatement();
276 ir::ReturnStatement *ParseReturnStatement();
277 ir::Statement *ParseExpressionStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
278 ir::LabelledStatement *ParseLabelledStatement(const lexer::LexerPosition &pos);
279 virtual void ValidateRestParameter(ir::Expression *param);
284 ir::MethodDefinition *BuildImplicitConstructor(ir::ClassDefinitionModifiers modifiers,
287 virtual void CreateImplicitConstructor(ir::MethodDefinition *&ctor, ArenaVector<ir::AstNode *> &properties,
288 ir::ClassDefinitionModifiers modifiers,
292 ir::Expression *ParseClassKey(ClassElementDescriptor *desc);
293 ir::ClassElement *ParseClassProperty(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
294 ir::Expression *propName, ir::TypeNode *typeAnnotation);
295 void AddPrivateElement(const ir::ClassElement *elem);
296 ir::ScriptFunction *ParseFunction(ParserStatus newStatus = ParserStatus::NO_OPTS);
297 ir::ModifierFlags GetAccessability(ir::ModifierFlags modifiers);
298 void CheckAccessorPair(const ArenaVector<ir::AstNode *> &properties, const ir::Expression *propName,
299 ir::MethodDefinitionKind methodKind, ir::ModifierFlags access);
300 ir::Identifier *ParseNamedImport(const lexer::Token &importedToken);
301 void ConsumeSemicolon(ir::Statement *statement);
302 ir::ExportAllDeclaration *ParseExportAllDeclaration(const lexer::SourcePosition &startLoc);
303 ir::ExportNamedDeclaration *ParseExportNamedSpecifiers(const lexer::SourcePosition &startLoc);
304 ir::Statement *ParseVariableDeclaration(VariableParsingFlags flags = VariableParsingFlags::NO_OPTS);
310 ir::VariableDeclarator *ParseVariableDeclarator(VariableParsingFlags flags);
311 ir::FunctionDeclaration *ParseFunctionDeclaration(bool canBeAnonymous = false,
313 ir::ETSStructDeclaration *ParseStructDeclaration(ir::ClassDefinitionModifiers modifiers,
314 ir::ModifierFlags flags = ir::ModifierFlags::NONE);
315 ir::ClassDeclaration *ParseClassDeclaration(ir::ClassDefinitionModifiers modifiers,
316 ir::ModifierFlags flags = ir::ModifierFlags::NONE);
317 FunctionSignature ParseFunctionSignature(ParserStatus status, ir::Identifier *className = nullptr);
321 virtual ir::Statement *ParseStatement(StatementParsingFlags flags = StatementParsingFlags::NONE);
323 virtual ir::Expression *ParseExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
325 virtual ir::Expression *ParseExpressionOrTypeAnnotation(lexer::TokenType type, ExpressionParseFlags flags);
327 virtual ir::Expression *ParsePatternElement(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS,
330 virtual bool ParsePotentialNonNullExpression(ir::Expression **returnExpression, lexer::SourcePosition startLoc);
331 virtual ir::AstNode *ParseImportSpecifiers(ArenaVector<ir::AstNode *> *specifiers);
332 virtual ir::Statement *ParseImportDeclaration(StatementParsingFlags flags);
334 virtual ir::Expression *ParsePropertyDefinition(
337 virtual ir::ObjectExpression *ParseObjectExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
339 virtual ir::ArrayExpression *ParseArrayExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
340 void ParseArrayExpressionErrorCheck(ir::ArrayExpression *arrayExpressionNode, ExpressionParseFlags flags,
342 virtual ir::ArrowFunctionExpression *ParsePotentialArrowExpression(ir::Expression **returnExpression,
344 virtual bool ParsePotentialGenericFunctionCall(ir::Expression *primaryExpr, ir::Expression **returnExpression,
346 virtual ir::Expression *ParsePotentialAsExpression(ir::Expression *primaryExpression);
348 virtual ir::Identifier *ParsePrimaryExpressionIdent(ExpressionParseFlags flags);
349 virtual void ValidateArrowFunctionRestParameter(ir::SpreadElement *restElement);
350 virtual ir::Statement *ParsePotentialExpressionStatement(StatementParsingFlags flags);
351 virtual ArenaVector<ir::Expression *> ParseFunctionParams();
352 virtual ir::Expression *CreateParameterThis(util::StringView className);
353 virtual ir::Expression *ParseFunctionParameter();
355 virtual void ParseCatchParamTypeAnnotation(ir::AnnotatedExpression *param);
357 virtual ir::ClassDefinition *ParseClassDefinition(ir::ClassDefinitionModifiers modifiers,
358 ir::ModifierFlags flags = ir::ModifierFlags::NONE);
359 virtual ir::Identifier *ParseClassIdent(ir::ClassDefinitionModifiers modifiers);
360 virtual ir::Statement *ParsePotentialConstEnum(VariableParsingFlags flags);
361 virtual ir::AstNode *ParseClassElement(const ArenaVector<ir::AstNode *> &properties,
362 ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags);
363 virtual bool CheckClassElement(ir::AstNode *property, ir::MethodDefinition *&ctor,
364 ArenaVector<ir::AstNode *> &properties);
365 virtual void ValidateClassMethodStart(ClassElementDescriptor *desc, ir::TypeNode *typeAnnotation);
366 virtual ir::MethodDefinition *ParseClassMethod(ClassElementDescriptor *desc,
367 const ArenaVector<ir::AstNode *> &properties,
368 ir::Expression *propName, lexer::SourcePosition *propEnd);
369 virtual void ValidateClassSetter(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
370 ir::Expression *propName, ir::ScriptFunction *func);
371 virtual void ValidateClassGetter(ClassElementDescriptor *desc, const ArenaVector<ir::AstNode *> &properties,
372 ir::Expression *propName, ir::ScriptFunction *func);
373 virtual ir::ModifierFlags ParseModifiers();
374 virtual ir::Statement *ParseConstStatement(StatementParsingFlags flags);
376 virtual ir::AnnotatedExpression *ParseVariableDeclaratorKey(VariableParsingFlags flags);
377 virtual ir::VariableDeclarator *ParseVariableDeclarator(ir::Expression *init, lexer::SourcePosition startLoc,
379 virtual ir::VariableDeclarator *ParseVariableDeclaratorInitializer(ir::Expression *init, VariableParsingFlags flags,
386 virtual void ThrowIfBodyEmptyError(ir::Statement *consequent);
390 virtual ir::Expression *ParsePrefixAssertionExpression();
392 virtual ir::Expression *ParseCoverParenthesizedExpressionAndArrowParameterList(
394 virtual void ThrowErrorIfStaticConstructor(ir::ModifierFlags flags);
395 virtual std::tuple<bool, bool, bool> ParseComputedClassFieldOrIndexSignature(ir::Expression **propName);
397 virtual ir::Expression *ParseUnaryOrPrefixUpdateExpression(
399 virtual ir::Expression *ParsePrimaryExpressionWithLiterals(ExpressionParseFlags flags);
400 ir::Expression *ParseHashMaskOperator();
401 ir::Expression *ParseClassExpression();
402 ir::Expression *ParsePunctuators(ExpressionParseFlags flags);
404 virtual ir::Expression *ParsePrimaryExpression(ExpressionParseFlags flags = ExpressionParseFlags::NO_OPTS);
405 virtual ir::Expression *ParsePostPrimaryExpression(ir::Expression *primaryExpr, lexer::SourcePosition startLoc,
407 ir::Expression *ParsePostPrimaryExpressionBackTick(ir::Expression *returnExpression,
409 ir::Expression *ParsePostPrimaryExpressionDot(ir::Expression *returnExpression, lexer::TokenType tokenType,
411 virtual ir::ClassElement *ParseClassStaticBlock();
412 virtual ParserStatus ValidateArrowParameter(ir::Expression *expr, bool *seenOptional);
413 void ValidateArrowParameterAssignment(ir::AssignmentExpression *expr);
414 virtual ArrowFunctionDescriptor ConvertToArrowParameter(ir::Expression *expr, bool isAsync);
415 virtual ir::Expression *ParseNewExpression();
417 virtual ir::TSTypeParameterDeclaration *ParseFunctionTypeParameters()
422 virtual ir::TypeNode *ParseFunctionReturnType([[maybe_unused]] ParserStatus status)
427 virtual ir::ScriptFunctionFlags ParseFunctionThrowMarker([[maybe_unused]] const bool isRethrowsAllowed)
429 return ir::ScriptFunctionFlags::NONE;
433 virtual ir::Identifier *ParseIdentifierFormatPlaceholder(std::optional<NodeFormatType> nodeFormat) const;
434 virtual ir::Statement *ParseStatementFormatPlaceholder() const;
435 virtual ir::AstNode *ParseTypeParametersFormatPlaceholder() const;
436 virtual ArenaVector<ir::AstNode *> &ParseAstNodesArrayFormatPlaceholder() const;
437 virtual ArenaVector<ir::Statement *> &ParseStatementsArrayFormatPlaceholder() const;
438 virtual ArenaVector<ir::Expression *> &ParseExpressionsArrayFormatPlaceholder() const;
440 virtual std::tuple<bool, ir::BlockStatement *, lexer::SourcePosition, bool> ParseFunctionBody(
441 const ArenaVector<ir::Expression *> ¶ms, ParserStatus newStatus, ParserStatus contextStatus);
442 virtual ir::AstNode *ParseImportDefaultSpecifier(ArenaVector<ir::AstNode *> *specifiers);
443 virtual ir::Statement *ParseExportDeclaration(StatementParsingFlags flags);
446 virtual ir::ExportDefaultDeclaration *ParseExportDefaultDeclaration(const lexer::SourcePosition &startLoc,
448 virtual ir::ExportNamedDeclaration *ParseNamedExportDeclaration(const lexer::SourcePosition &startLoc);
450 virtual ir::Statement *ParseTryStatement();
451 virtual ir::ThrowStatement *ParseThrowStatement();
452 virtual ir::DebuggerStatement *ParseDebuggerStatement();
454 virtual ir::Statement *ParseModuleDeclaration(StatementParsingFlags flags = StatementParsingFlags::NONE)
459 virtual ir::Statement *ParseInterfaceDeclaration([[maybe_unused]] bool isStatic)
465 virtual ir::Statement *ParseEnumDeclaration([[maybe_unused]] bool isConst = false,
471 virtual std::tuple<ir::Expression *, ir::TSTypeParameterInstantiation *> ParseSuperClass();
472 virtual ir::Expression *ParseSuperClassReference();
474 using ClassBody = std::tuple<ir::MethodDefinition *, ArenaVector<ir::AstNode *>, lexer::SourceRange>;
475 ClassBody ParseClassBody(ir::ClassDefinitionModifiers modifiers, ir::ModifierFlags flags = ir::ModifierFlags::NONE);