Lines Matching defs:pos
277 Expression(int pos, NodeType type) : AstNode(pos, type) {
359 Declaration(int pos, NodeType type) : AstNode(pos, type), next_(nullptr) {}
381 explicit VariableDeclaration(int pos, bool is_nested = false)
382 : Declaration(pos, kVariableDeclaration) {
401 NestedVariableDeclaration(Scope* scope, int pos)
402 : VariableDeclaration(pos, true), scope_(scope) {}
422 FunctionDeclaration(FunctionLiteral* fun, int pos)
423 : Declaration(pos, kFunctionDeclaration), fun_(fun) {}
435 IterationStatement(int pos, NodeType type)
436 : BreakableStatement(pos, type), body_(nullptr) {}
457 explicit DoWhileStatement(int pos)
458 : IterationStatement(pos, kDoWhileStatement), cond_(nullptr) {}
477 explicit WhileStatement(int pos)
478 : IterationStatement(pos, kWhileStatement), cond_(nullptr) {}
502 explicit ForStatement(int pos)
503 : IterationStatement(pos, kForStatement),
540 ForEachStatement(int pos, NodeType type)
541 : IterationStatement(pos, type), each_(nullptr), subject_(nullptr) {}
552 explicit ForInStatement(int pos) : ForEachStatement(pos, kForInStatement) {}
564 ForOfStatement(int pos, IteratorType type)
565 : ForEachStatement(pos, kForOfStatement), type_(type) {}
579 ExpressionStatement(Expression* expression, int pos)
580 : Statement(pos, kExpressionStatement), expression_(expression) {}
588 JumpStatement(int pos, NodeType type) : Statement(pos, type) {}
600 ContinueStatement(IterationStatement* target, int pos)
601 : JumpStatement(pos, kContinueStatement), target_(target) {}
615 BreakStatement(BreakableStatement* target, int pos)
616 : JumpStatement(pos, kBreakStatement), target_(target) {}
644 ReturnStatement(Expression* expression, Type type, int pos, int end_position)
645 : JumpStatement(pos, kReturnStatement),
670 int pos)
671 : Statement(pos, kWithStatement),
713 SwitchStatement(Zone* zone, Expression* tag, int pos)
714 : BreakableStatement(pos, kSwitchStatement), tag_(tag), cases_(4, zone) {}
743 Statement* else_statement, int pos)
744 : Statement(pos, kIfStatement),
761 TryStatement(Block* try_block, int pos, NodeType type)
762 : Statement(pos, type), try_block_(try_block) {}
841 HandlerTable::CatchPrediction catch_prediction, int pos)
842 : TryStatement(try_block, pos, kTryCatchStatement),
862 TryFinallyStatement(Block* try_block, Block* finally_block, int pos)
863 : TryStatement(try_block, pos, kTryFinallyStatement),
875 explicit DebuggerStatement(int pos) : Statement(pos, kDebuggerStatement) {}
907 SloppyBlockFunctionStatement(int pos, Variable* var, Token::Value init,
909 : Statement(pos, kSloppyBlockFunctionStatement),
1050 MaterializedLiteral(int pos, NodeType type) : Expression(pos, type) {}
1072 RegExpLiteral(const AstRawString* pattern, int flags, int pos)
1073 : MaterializedLiteral(pos, kRegExpLiteral),
1093 AggregateLiteral(int pos, NodeType type) : MaterializedLiteral(pos, type) {}
1372 uint32_t boilerplate_properties, int pos,
1374 : AggregateLiteral(pos, kObjectLiteral),
1441 int first_spread_index, int pos)
1442 : AggregateLiteral(pos, kArrayLiteral),
1456 explicit ThisExpression(int pos) : Expression(pos, kThisExpression) {}
1660 Property(Expression* obj, Expression* key, int pos, bool optional_chain)
1661 : Expression(pos, kProperty), obj_(obj), key_(key) {
1683 const ScopedPtrList<Expression>& arguments, int pos, bool has_spread)
1684 : Expression(pos, type),
1751 const ScopedPtrList<Expression>& arguments, int pos, bool has_spread,
1753 : CallBase(zone, kCall, expression, arguments, pos, has_spread) {
1761 const ScopedPtrList<Expression>& arguments, int pos,
1763 : CallBase(zone, kCall, expression, arguments, pos, false) {
1780 const ScopedPtrList<Expression>& arguments, int pos, bool has_spread)
1781 : CallBase(zone, kCallNew, expression, arguments, pos, has_spread) {}
1809 const ScopedPtrList<Expression>& arguments, int pos)
1810 : Expression(pos, kCallRuntime),
1814 const ScopedPtrList<Expression>& arguments, int pos)
1815 : Expression(pos, kCallRuntime),
1835 UnaryOperation(Token::Value op, Expression* expression, int pos)
1836 : Expression(pos, kUnaryOperation), expression_(expression) {
1861 BinaryOperation(Token::Value op, Expression* left, Expression* right, int pos)
1862 : Expression(pos, kBinaryOperation), left_(left), right_(right) {
1886 void AddSubsequent(Expression* expr, int pos) {
1887 subsequent_.emplace_back(expr, pos);
1925 NaryOperationEntry(Expression* e, int pos)
1926 : expression(e), op_position(pos) {}
1946 CountOperation(Token::Value op, bool is_prefix, Expression* expr, int pos)
1947 : Expression(pos, kCountOperation), expression_(expr) {
1974 int pos)
1975 : Expression(pos, kCompareOperation), left_(left), right_(right) {
1997 Spread(Expression* expression, int pos, int expr_pos)
1998 : Expression(pos, kSpread),
2048 Expression* value, int pos);
2070 int pos, BinaryOperation* binary_operation)
2071 : Assignment(kCompoundAssignment, op, target, value, pos),
2107 Suspend(NodeType node_type, Expression* expression, int pos,
2109 : Expression(pos, node_type), expression_(expression) {
2122 Yield(Expression* expression, int pos, OnAbruptResume on_abrupt_resume)
2123 : Suspend(kYield, expression, pos, on_abrupt_resume) {}
2130 YieldStar(Expression* expression, int pos)
2131 : Suspend(kYieldStar, expression, pos,
2140 Await(Expression* expression, int pos)
2141 : Suspend(kAwait, expression, pos, Suspend::kOnExceptionThrow) {}
2152 Throw(Expression* exception, int pos)
2153 : Expression(pos, kThrow), exception_(exception) {}
2178 void set_function_token_position(int pos) { function_token_position_ = pos; }
2456 InitializeClassMembersStatement(ZonePtrList<Property>* fields, int pos)
2457 : Statement(pos, kInitializeClassMembersStatement), fields_(fields) {}
2473 int pos)
2474 : Statement(pos, kInitializeClassStaticElementsStatement),
2574 int pos)
2575 : Expression(pos, kNativeFunctionLiteral),
2592 explicit SuperPropertyReference(VariableProxy* home_object, int pos)
2593 : Expression(pos, kSuperPropertyReference), home_object_(home_object) {}
2610 VariableProxy* this_function_var, int pos)
2611 : Expression(pos, kSuperCallReference),
2633 ImportCallExpression(Expression* specifier, int pos)
2634 : Expression(pos, kImportCallExpression),
2639 int pos)
2640 : Expression(pos, kImportCallExpression),
2655 explicit EmptyParentheses(int pos) : Expression(pos, kEmptyParentheses) {
2679 const ZonePtrList<const AstRawString>* raw_strings, int pos)
2680 : Expression(pos, kGetTemplateObject),
2701 const ZonePtrList<Expression>* substitutions, int pos)
2702 : Expression(pos, kTemplateLiteral),
2822 VariableDeclaration* NewVariableDeclaration(int pos) {
2823 return zone_->New<VariableDeclaration>(pos);
2827 int pos) {
2828 return zone_->New<NestedVariableDeclaration>(scope, pos);
2831 FunctionDeclaration* NewFunctionDeclaration(FunctionLiteral* fun, int pos) {
2832 return zone_->New<FunctionDeclaration>(fun, pos);
2851 NodeType* New##NodeType(int pos) { return zone_->New<NodeType>(pos); }
2857 SwitchStatement* NewSwitchStatement(Expression* tag, int pos) {
2858 return zone_->New<SwitchStatement>(zone_, tag, pos);
2862 int pos) {
2865 return zone_->New<ForInStatement>(pos);
2868 return zone_->New<ForOfStatement>(pos, IteratorType::kNormal);
2874 ForOfStatement* NewForOfStatement(int pos, IteratorType type) {
2875 return zone_->New<ForOfStatement>(pos, type);
2878 ExpressionStatement* NewExpressionStatement(Expression* expression, int pos) {
2879 return zone_->New<ExpressionStatement>(expression, pos);
2882 ContinueStatement* NewContinueStatement(IterationStatement* target, int pos) {
2883 return zone_->New<ContinueStatement>(target, pos);
2886 BreakStatement* NewBreakStatement(BreakableStatement* target, int pos) {
2887 return zone_->New<BreakStatement>(target, pos);
2891 Expression* expression, int pos,
2894 pos, end_position);
2897 ReturnStatement* NewAsyncReturnStatement(Expression* expression, int pos,
2900 expression, ReturnStatement::kAsyncReturn, pos, end_position);
2904 Expression* expression, int pos,
2907 expression, ReturnStatement::kSyntheticAsyncReturn, pos, end_position);
2913 int pos) {
2914 return zone_->New<WithStatement>(scope, expression, statement, pos);
2918 Statement* else_statement, int pos) {
2920 pos);
2924 Block* catch_block, int pos) {
2926 HandlerTable::CAUGHT, pos);
2932 int pos) {
2934 HandlerTable::UNCAUGHT, pos);
2940 int pos) {
2942 HandlerTable::ASYNC_AWAIT, pos);
2948 int pos) {
2950 try_block, scope, catch_block, HandlerTable::UNCAUGHT_ASYNC_AWAIT, pos);
2954 Block* finally_block, int pos) {
2955 return zone_->New<TryFinallyStatement>(try_block, finally_block, pos);
2958 DebuggerStatement* NewDebuggerStatement(int pos) {
2959 return zone_->New<DebuggerStatement>(pos);
2977 class ThisExpression* NewThisExpression(int pos) {
2978 DCHECK_NE(pos, kNoSourcePosition);
2979 return zone_->New<class ThisExpression>(pos);
2987 int pos, Variable* var, Token::Value init) {
2988 return zone_->New<SloppyBlockFunctionStatement>(pos, var, init,
2997 Literal* NewStringLiteral(const AstRawString* string, int pos) {
2999 return zone_->New<Literal>(string, pos);
3002 Literal* NewNumberLiteral(double number, int pos);
3004 Literal* NewSmiLiteral(int number, int pos) {
3005 return zone_->New<Literal>(number, pos);
3008 Literal* NewBigIntLiteral(AstBigInt bigint, int pos) {
3009 return zone_->New<Literal>(bigint, pos);
3012 Literal* NewBooleanLiteral(bool b, int pos) {
3013 return zone_->New<Literal>(b, pos);
3016 Literal* NewNullLiteral(int pos) {
3017 return zone_->New<Literal>(Literal::kNull, pos);
3020 Literal* NewUndefinedLiteral(int pos) {
3021 return zone_->New<Literal>(Literal::kUndefined, pos);
3030 uint32_t boilerplate_properties, int pos, bool has_rest_property,
3033 pos, has_rest_property, home_object);
3051 int pos) {
3052 return zone_->New<RegExpLiteral>(pattern, flags, pos);
3056 int pos) {
3057 return zone_->New<ArrayLiteral>(zone_, values, -1, pos);
3061 int first_spread_index, int pos) {
3062 return zone_->New<ArrayLiteral>(zone_, values, first_spread_index, pos);
3090 Property* NewProperty(Expression* obj, Expression* key, int pos,
3092 return zone_->New<Property>(obj, key, pos, optional_chain);
3096 const ScopedPtrList<Expression>& arguments, int pos,
3101 return zone_->New<Call>(zone_, expression, arguments, pos, has_spread,
3106 const ScopedPtrList<Expression>& arguments, int pos) {
3107 return zone_->New<Call>(zone_, expression, arguments, pos,
3112 const ScopedPtrList<Expression>& arguments, int pos,
3114 return zone_->New<CallNew>(zone_, expression, arguments, pos, has_spread);
3119 int pos) {
3121 pos);
3126 int pos) {
3127 return zone_->New<CallRuntime>(zone_, function, arguments, pos);
3132 int pos) {
3133 return zone_->New<CallRuntime>(zone_, context_index, arguments, pos);
3138 int pos) {
3139 return zone_->New<UnaryOperation>(op, expression, pos);
3145 int pos) {
3146 return zone_->New<BinaryOperation>(op, left, right, pos);
3157 int pos) {
3158 return zone_->New<CountOperation>(op, is_prefix, expr, pos);
3164 int pos) {
3165 return zone_->New<CompareOperation>(op, left, right, pos);
3168 Spread* NewSpread(Expression* expression, int pos, int expr_pos) {
3169 return zone_->New<Spread>(expression, pos, expr_pos);
3183 int pos) {
3194 pos);
3197 op, target, value, pos,
3199 pos + 1));
3203 Suspend* NewYield(Expression* expression, int pos,
3205 if (!expression) expression = NewUndefinedLiteral(pos);
3206 return zone_->New<Yield>(expression, pos, on_abrupt_resume);
3209 YieldStar* NewYieldStar(Expression* expression, int pos) {
3210 return zone_->New<YieldStar>(expression, pos);
3213 Await* NewAwait(Expression* expression, int pos) {
3214 if (!expression) expression = NewUndefinedLiteral(pos);
3215 return zone_->New<Await>(expression, pos);
3218 Throw* NewThrow(Expression* exception, int pos) {
3219 return zone_->New<Throw>(exception, pos);
3289 int pos) {
3290 return zone_->New<NativeFunctionLiteral>(name, extension, pos);
3294 VariableProxy* home_object_var, int pos) {
3295 return zone_->New<SuperPropertyReference>(home_object_var, pos);
3300 int pos) {
3302 pos);
3305 EmptyParentheses* NewEmptyParentheses(int pos) {
3306 return zone_->New<EmptyParentheses>(pos);
3311 const ZonePtrList<const AstRawString>* raw_strings, int pos) {
3312 return zone_->New<GetTemplateObject>(cooked_strings, raw_strings, pos);
3317 const ZonePtrList<Expression>* substitutions, int pos) {
3318 return zone_->New<TemplateLiteral>(string_parts, substitutions, pos);
3322 int pos) {
3323 return zone_->New<ImportCallExpression>(specifier, pos);
3328 int pos) {
3329 return zone_->New<ImportCallExpression>(specifier, import_assertions, pos);
3333 ZonePtrList<ClassLiteral::Property>* args, int pos) {
3334 return zone_->New<InitializeClassMembersStatement>(args, pos);
3339 ZonePtrList<ClassLiteral::StaticElement>* args, int pos) {
3340 return zone_->New<InitializeClassStaticElementsStatement>(args, pos);