Lines Matching defs:Expression
121 class Expression;
189 class Expression : public AstNode {
203 // True iff the expression is a valid reference expression.
215 // True iff the expression is a class or function expression without
219 // True iff the expression is a concise method definition.
222 // True iff the expression is an accessor function definition.
225 // True iff the expression is a literal represented as a smi.
228 // True iff the expression is a literal represented as a number.
231 // True iff the expression is a string literal.
234 // True iff the expression is the null literal.
237 // True iff the expression is the hole literal.
240 // True if we can prove that the expression is the undefined literal. Note
247 Expression(int pos, NodeType type) : AstNode(pos, type) {}
365 class DoExpression final : public Expression {
374 : Expression(pos, kDoExpression), block_(block), result_(result) {
499 void Initialize(Expression* cond, Statement* body) {
504 Expression* cond() const { return cond_; }
514 Expression* cond_;
520 void Initialize(Expression* cond, Statement* body) {
525 Expression* cond() const { return cond_; }
535 Expression* cond_;
541 void Initialize(Statement* init, Expression* cond, Statement* next,
550 Expression* cond() const { return cond_; }
564 Expression* cond_;
592 void Initialize(Expression* each, Expression* subject, Statement* body) {
598 Expression* enumerable() const {
602 Expression* each() const { return each_; }
603 Expression* subject() const { return subject_; }
619 Expression* each_;
620 Expression* subject_;
630 Expression* assign_iterator, Expression* assign_next,
631 Expression* next_result, Expression* result_done,
632 Expression* assign_each) {
647 Expression* assign_iterator() const {
652 Expression* assign_next() const { return assign_next_; }
655 Expression* next_result() const {
660 Expression* result_done() const {
665 Expression* assign_each() const {
669 void set_assign_iterator(Expression* e) { assign_iterator_ = e; }
670 void set_assign_next(Expression* e) { assign_next_ = e; }
671 void set_next_result(Expression* e) { next_result_ = e; }
672 void set_result_done(Expression* e) { result_done_ = e; }
673 void set_assign_each(Expression* e) { assign_each_ = e; }
688 Expression* assign_iterator_;
689 Expression* assign_next_;
690 Expression* next_result_;
691 Expression* result_done_;
692 Expression* assign_each_;
698 void set_expression(Expression* e) { expression_ = e; }
699 Expression* expression() const { return expression_; }
705 ExpressionStatement(Expression* expression, int pos)
706 : Statement(pos, kExpressionStatement), expression_(expression) {}
708 Expression* expression_;
752 Expression* expression() const { return expression_; }
762 ReturnStatement(Expression* expression, Type type, int pos, int end_position)
764 expression_(expression),
769 Expression* expression_;
780 Expression* expression() const { return expression_; }
787 WithStatement(Scope* scope, Expression* expression, Statement* statement,
791 expression_(expression),
795 Expression* expression_;
802 Expression* label() const {
811 CaseClause(Expression* label, ZonePtrList<Statement>* statements);
813 Expression* label_;
822 Expression* tag() const { return tag_; }
823 void set_tag(Expression* t) { tag_ = t; }
831 Expression* tag, int pos)
838 Expression* tag_;
853 Expression* condition() const { return condition_; }
868 IfStatement(Expression* condition, Statement* then_statement,
875 Expression* condition_;
1016 class Literal final : public Expression {
1100 class TypeField : public BitField<Type, Expression::kNextBitFieldIndex, 4> {};
1102 Literal(int smi, int position) : Expression(position, kLiteral), smi_(smi) {
1107 : Expression(position, kLiteral), number_(number) {
1112 : Expression(position, kLiteral), bigint_(bigint) {
1117 : Expression(position, kLiteral), string_(string) {
1122 : Expression(position, kLiteral), symbol_(symbol) {
1127 : Expression(position, kLiteral), boolean_(boolean) {
1131 Literal(Type type, int position) : Expression(position, kLiteral) {
1147 class MaterializedLiteral : public Expression {
1154 MaterializedLiteral(int pos, NodeType type) : Expression(pos, type) {}
1168 // If the expression is a literal, return the literal value;
1169 // if the expression is a materialized literal and is_simple
1173 Handle<Object> GetBoilerplateValue(Expression* expression, Isolate* isolate);
1263 Expression* key() const { return key_; }
1264 Expression* value() const { return value_; }
1270 LiteralProperty(Expression* key, Expression* value, bool is_computed_name)
1273 Expression* key_;
1274 Expression* value_;
1308 ObjectLiteralProperty(Expression* key, Expression* value, Kind kind,
1310 ObjectLiteralProperty(AstValueFactory* ast_value_factory, Expression* key,
1311 Expression* value, bool is_computed_name);
1476 ZonePtrList<Expression>* values() const { return values_; }
1508 ArrayLiteral(ZonePtrList<Expression>* values, int first_spread_index, int pos)
1515 ZonePtrList<Expression>* values_;
1520 class VariableProxy final : public Expression {
1591 : Expression(start_position, kVariableProxy),
1603 class IsThisField : public BitField<bool, Expression::kNextBitFieldIndex, 1> {
1630 class Property final : public Expression {
1634 Expression* obj() const { return obj_; }
1635 Expression* key() const { return key_; }
1651 Property(Expression* obj, Expression* key, int pos)
1652 : Expression(pos, kProperty), obj_(obj), key_(key) {
1655 Expression* obj_;
1656 Expression* key_;
1661 class ResolvedProperty final : public Expression {
1673 : Expression(pos, kResolvedProperty), object_(obj), property_(property) {}
1679 class Call final : public Expression {
1681 Expression* expression() const { return expression_; }
1682 ZonePtrList<Expression>* arguments() const { return arguments_; }
1721 Call(Expression* expression, ZonePtrList<Expression>* arguments, int pos,
1723 : Expression(pos, kCall), expression_(expression), arguments_(arguments) {
1729 Call(Expression* expression, ZonePtrList<Expression>* arguments, int pos,
1731 : Expression(pos, kCall), expression_(expression), arguments_(arguments) {
1737 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
1741 Expression* expression_;
1742 ZonePtrList<Expression>* arguments_;
1746 class CallNew final : public Expression {
1748 Expression* expression() const { return expression_; }
1749 ZonePtrList<Expression>* arguments() const { return arguments_; }
1758 CallNew(Expression* expression, ZonePtrList<Expression>* arguments, int pos)
1759 : Expression(pos, kCallNew),
1760 expression_(expression),
1763 Expression* expression_;
1764 ZonePtrList<Expression>* arguments_;
1771 class CallRuntime final : public Expression {
1773 ZonePtrList<Expression>* arguments() const { return arguments_; }
1791 ZonePtrList<Expression>* arguments, int pos)
1792 : Expression(pos, kCallRuntime),
1795 CallRuntime(int context_index, ZonePtrList<Expression>* arguments, int pos)
1796 : Expression(pos, kCallRuntime),
1803 ZonePtrList<Expression>* arguments_;
1807 class UnaryOperation final : public Expression {
1810 Expression* expression() const { return expression_; }
1815 UnaryOperation(Token::Value op, Expression* expression, int pos)
1816 : Expression(pos, kUnaryOperation), expression_(expression) {
1821 Expression* expression_;
1824 : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
1828 class BinaryOperation final : public Expression {
1831 Expression* left() const { return left_; }
1832 Expression* right() const { return right_; }
1835 // sub-expression in |subexpr| and the literal Smi in |literal|.
1836 bool IsSmiLiteralOperation(Expression** subexpr, Smi** literal);
1841 BinaryOperation(Token::Value op, Expression* left, Expression* right, int pos)
1842 : Expression(pos, kBinaryOperation), left_(left), right_(right) {
1847 Expression* left_;
1848 Expression* right_;
1851 : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
1854 class NaryOperation final : public Expression {
1857 Expression* first() const { return first_; }
1858 Expression* subsequent(size_t index) const {
1859 return subsequent_[index].expression;
1867 void AddSubsequent(Expression* expr, int pos) {
1874 NaryOperation(Zone* zone, Token::Value op, Expression* first,
1876 : Expression(first->position(), kNaryOperation),
1885 // Nary operations store the first (lhs) child expression inline, and the
1887 // their operation's position. Note that the Nary operation expression's
1900 Expression* first_;
1903 Expression* expression;
1905 NaryOperationEntry(Expression* e, int pos)
1906 : expression(e), op_position(pos) {}
1911 : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
1914 class CountOperation final : public Expression {
1921 Expression* expression() const { return expression_; }
1926 CountOperation(Token::Value op, bool is_prefix, Expression* expr, int pos)
1927 : Expression(pos, kCountOperation), expression_(expr) {
1932 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
1935 Expression* expression_;
1939 class CompareOperation final : public Expression {
1942 Expression* left() const { return left_; }
1943 Expression* right() const { return right_; }
1946 bool IsLiteralCompareTypeof(Expression** expr, Literal** literal);
1947 bool IsLiteralCompareUndefined(Expression** expr);
1948 bool IsLiteralCompareNull(Expression** expr);
1953 CompareOperation(Token::Value op, Expression* left, Expression* right,
1955 : Expression(pos, kCompareOperation), left_(left), right_(right) {
1960 Expression* left_;
1961 Expression* right_;
1964 : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
1968 class Spread final : public Expression {
1970 Expression* expression() const { return expression_; }
1977 Spread(Expression* expression, int pos, int expr_pos)
1978 : Expression(pos, kSpread),
1980 expression_(expression) {}
1983 Expression* expression_;
1989 class StoreInArrayLiteral final : public Expression {
1991 Expression* array() const { return array_; }
1992 Expression* index() const { return index_; }
1993 Expression* value() const { return value_; }
1998 StoreInArrayLiteral(Expression* array, Expression* index, Expression* value,
2000 : Expression(position, kStoreInArrayLiteral),
2005 Expression* array_;
2006 Expression* index_;
2007 Expression* value_;
2010 class Conditional final : public Expression {
2012 Expression* condition() const { return condition_; }
2013 Expression* then_expression() const { return then_expression_; }
2014 Expression* else_expression() const { return else_expression_; }
2019 Conditional(Expression* condition, Expression* then_expression,
2020 Expression* else_expression, int position)
2021 : Expression(position, kConditional),
2026 Expression* condition_;
2027 Expression* then_expression_;
2028 Expression* else_expression_;
2031 class Assignment : public Expression {
2034 Expression* target() const { return target_; }
2035 Expression* value() const { return value_; }
2050 Assignment(NodeType type, Token::Value op, Expression* target,
2051 Expression* value, int pos);
2057 : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
2061 Expression* target_;
2062 Expression* value_;
2072 CompoundAssignment(Token::Value op, Expression* target, Expression* value,
2095 class RewritableExpression final : public Expression {
2097 Expression* expression() const { return expr_; }
2103 void Rewrite(Expression* new_expression) {
2117 RewritableExpression(Expression* expression, Scope* scope)
2118 : Expression(expression->position(), kRewritableExpression),
2119 expr_(expression),
2122 DCHECK(!expression->IsRewritableExpression());
2125 Expression* expr_;
2129 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2141 Expression {
2150 Expression* expression() const { return expression_; }
2161 Suspend(NodeType node_type, Expression* expression, int pos,
2163 : Expression(pos, node_type), expression_(expression) {
2167 Expression* expression_;
2170 : public BitField<OnAbruptResume, Expression::kNextBitFieldIndex, 1> {};
2176 Yield(Expression* expression, int pos, OnAbruptResume on_abrupt_resume)
2177 : Suspend(kYield, expression, pos, on_abrupt_resume) {}
2183 YieldStar(Expression* expression, int pos)
2184 : Suspend(kYieldStar, expression, pos,
2192 Await(Expression* expression, int pos)
2193 : Suspend(kAwait, expression, pos, Suspend::kOnExceptionThrow) {}
2196 class Throw final : public Expression {
2198 Expression* exception() const { return exception_; }
2203 Throw(Expression* exception, int pos)
2204 : Expression(pos, kThrow), exception_(exception) {}
2206 Expression* exception_;
2210 class FunctionLiteral final : public Expression {
2257 static bool NeedsHomeObject(Expression* expr);
2368 : Expression(position, kFunctionLiteral),
2392 : public BitField<FunctionType, Expression::kNextBitFieldIndex, 3> {};
2449 ClassLiteralProperty(Expression* key, Expression* value, Kind kind,
2472 class ClassLiteral final : public Expression {
2478 Expression* extends() const { return extends_; }
2508 ClassLiteral(Scope* scope, Variable* class_variable, Expression* extends,
2515 : Expression(start_position, kClassLiteral),
2533 Expression* extends_;
2539 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2547 class NativeFunctionLiteral final : public Expression {
2558 : Expression(pos, kNativeFunctionLiteral),
2567 class ThisFunction final : public Expression {
2570 explicit ThisFunction(int pos) : Expression(pos, kThisFunction) {}
2574 class SuperPropertyReference final : public Expression {
2577 Expression* home_object() const { return home_object_; }
2582 SuperPropertyReference(VariableProxy* this_var, Expression* home_object,
2584 : Expression(pos, kSuperPropertyReference),
2592 Expression* home_object_;
2596 class SuperCallReference final : public Expression {
2607 : Expression(pos, kSuperCallReference),
2623 class ImportCallExpression final : public Expression {
2625 Expression* argument() const { return argument_; }
2630 ImportCallExpression(Expression* argument, int pos)
2631 : Expression(pos, kImportCallExpression), argument_(argument) {}
2633 Expression* argument_;
2637 // arguments and is not actually a valid expression.
2638 class EmptyParentheses final : public Expression {
2642 explicit EmptyParentheses(int pos) : Expression(pos, kEmptyParentheses) {}
2650 class GetIterator final : public Expression {
2654 Expression* iterable() const { return iterable_; }
2656 Expression* iterable_for_call_printer() const {
2664 GetIterator(Expression* iterable, Expression* destructured_iterable,
2666 : Expression(pos, kGetIterator),
2671 GetIterator(Expression* iterable, IteratorType hint, int pos)
2672 : Expression(pos, kGetIterator),
2678 Expression* iterable_;
2683 Expression* destructured_iterable_;
2688 class GetTemplateObject final : public Expression {
2704 : Expression(pos, kGetTemplateObject),
2712 class TemplateLiteral final : public Expression {
2717 const ZonePtrList<Expression>* substitutions() const {
2724 const ZonePtrList<Expression>* substitutions, int pos)
2725 : Expression(pos, kTemplateLiteral),
2730 const ZonePtrList<Expression>* substitutions_;
2755 void VisitExpressions(ZonePtrList<Expression>* expressions) {
2759 // undefined expression or literal? Revisit this code if this
2761 Expression* expression = expressions->at(i);
2762 if (expression != nullptr) Visit(expression);
2869 Expression* tag, int pos) {
2894 ExpressionStatement* NewExpressionStatement(Expression* expression, int pos) {
2895 return new (zone_) ExpressionStatement(expression, pos);
2906 ReturnStatement* NewReturnStatement(Expression* expression, int pos,
2908 return new (zone_) ReturnStatement(expression, ReturnStatement::kNormal,
2913 Expression* expression, int pos, int end_position = kNoSourcePosition) {
2915 expression, ReturnStatement::kAsyncReturn, pos, end_position);
2919 Expression* expression,
2922 return new (zone_) WithStatement(scope, expression, statement, pos);
2925 IfStatement* NewIfStatement(Expression* condition, Statement* then_statement,
2979 CaseClause* NewCaseClause(Expression* label,
3027 Expression* key, Expression* value, ObjectLiteralProperty::Kind kind,
3033 ObjectLiteral::Property* NewObjectLiteralProperty(Expression* key,
3034 Expression* value,
3045 ArrayLiteral* NewArrayLiteral(ZonePtrList<Expression>* values, int pos) {
3049 ArrayLiteral* NewArrayLiteral(ZonePtrList<Expression>* values,
3075 Property* NewProperty(Expression* obj, Expression* key, int pos) {
3085 Call* NewCall(Expression* expression, ZonePtrList<Expression>* arguments,
3087 return new (zone_) Call(expression, arguments, pos, possibly_eval);
3090 Call* NewTaggedTemplate(Expression* expression,
3091 ZonePtrList<Expression>* arguments, int pos) {
3093 Call(expression, arguments, pos, Call::TaggedTemplateTag::kTrue);
3096 CallNew* NewCallNew(Expression* expression,
3097 ZonePtrList<Expression>* arguments, int pos) {
3098 return new (zone_) CallNew(expression, arguments, pos);
3102 ZonePtrList<Expression>* arguments, int pos) {
3107 ZonePtrList<Expression>* arguments, int pos) {
3112 ZonePtrList<Expression>* arguments, int pos) {
3117 Expression* expression,
3119 return new (zone_) UnaryOperation(op, expression, pos);
3123 Expression* left,
3124 Expression* right,
3129 NaryOperation* NewNaryOperation(Token::Value op, Expression* first,
3136 Expression* expr,
3142 Expression* left,
3143 Expression* right,
3148 Spread* NewSpread(Expression* expression, int pos, int expr_pos) {
3149 return new (zone_) Spread(expression, pos, expr_pos);
3152 StoreInArrayLiteral* NewStoreInArrayLiteral(Expression* array,
3153 Expression* index,
3154 Expression* value, int pos) {
3158 Conditional* NewConditional(Expression* condition,
3159 Expression* then_expression,
3160 Expression* else_expression,
3166 RewritableExpression* NewRewritableExpression(Expression* expression,
3168 DCHECK_NOT_NULL(expression);
3169 return new (zone_) RewritableExpression(expression, scope);
3173 Expression* target,
3174 Expression* value,
3193 Suspend* NewYield(Expression* expression, int pos,
3195 if (!expression) expression = NewUndefinedLiteral(pos);
3196 return new (zone_) Yield(expression, pos, on_abrupt_resume);
3199 YieldStar* NewYieldStar(Expression* expression, int pos) {
3200 DCHECK_NOT_NULL(expression);
3201 return new (zone_) YieldStar(expression, pos);
3204 Await* NewAwait(Expression* expression, int pos) {
3205 if (!expression) expression = NewUndefinedLiteral(pos);
3206 return new (zone_) Await(expression, pos);
3209 Throw* NewThrow(Expression* exception, int pos) {
3246 Expression* key, Expression* value, ClassLiteralProperty::Kind kind,
3253 Scope* scope, Variable* variable, Expression* extends,
3283 Expression* home_object,
3300 GetIterator* NewGetIterator(Expression* iterable,
3301 Expression* destructured_iterable,
3306 GetIterator* NewGetIterator(Expression* iterable, IteratorType hint,
3319 const ZonePtrList<Expression>* substitutions, int pos) {
3323 ImportCallExpression* NewImportCallExpression(Expression* args, int pos) {
3354 ->expression() \
3364 reinterpret_cast<const RewritableExpression*>(this)->expression(); \
3376 reinterpret_cast<const RewritableExpression*>(this)->expression(); \
