Lines Matching full:expression
120 class Expression;
289 class Expression : public AstNode {
303 // Mark this expression as being in tail position.
306 // True iff the expression is a valid reference expression.
318 // True iff the expression is a class or function expression without
322 // True iff the expression is a literal represented as a smi.
325 // True iff the expression is a literal represented as a number.
328 // True iff the expression is a string literal.
331 // True iff the expression is the null literal.
334 // True if we can prove that the expression is the undefined literal. Note
338 // True iff the expression is a valid target for an assignment.
365 Expression(int pos, NodeType type)
480 class DoExpression final : public Expression {
496 : Expression(pos, kDoExpression),
503 static int parent_num_ids() { return Expression::num_ids(); }
604 void Initialize(Expression* cond, Statement* body) {
609 Expression* cond() const { return cond_; }
610 void set_cond(Expression* e) { cond_ = e; }
625 Expression* cond_;
631 void Initialize(Expression* cond, Statement* body) {
636 Expression* cond() const { return cond_; }
637 void set_cond(Expression* e) { cond_ = e; }
652 Expression* cond_;
659 Expression* cond,
669 Expression* cond() const { return cond_; }
673 void set_cond(Expression* e) { cond_ = e; }
693 Expression* cond_;
720 void Initialize(Expression* each, Expression* subject, Statement* body) {
726 Expression* enumerable() const {
730 Expression* each() const { return each_; }
731 Expression* subject() const { return subject_; }
733 void set_each(Expression* e) { each_ = e; }
734 void set_subject(Expression* e) { subject_ = e; }
774 Expression* each_;
775 Expression* subject_;
787 Expression* assign_iterator, Expression* next_result,
788 Expression* result_done, Expression* assign_each) {
802 Expression* assign_iterator() const {
807 Expression* next_result() const {
812 Expression* result_done() const {
817 Expression* assign_each() const {
821 void set_assign_iterator(Expression* e) { assign_iterator_ = e; }
822 void set_next_result(Expression* e) { next_result_ = e; }
823 void set_result_done(Expression* e) { result_done_ = e; }
824 void set_assign_each(Expression* e) { assign_each_ = e; }
838 Expression* assign_iterator_;
839 Expression* next_result_;
840 Expression* result_done_;
841 Expression* assign_each_;
847 void set_expression(Expression* e) { expression_ = e; }
848 Expression* expression() const { return expression_; }
854 ExpressionStatement(Expression* expression, int pos)
855 : Statement(pos, kExpressionStatement), expression_(expression) {}
857 Expression* expression_;
901 Expression* expression() const { return expression_; }
903 void set_expression(Expression* e) { expression_ = e; }
910 ReturnStatement(Expression* expression, Type type, int pos)
911 : JumpStatement(pos, kReturnStatement), expression_(expression) {
915 Expression* expression_;
925 Expression* expression() const { return expression_; }
926 void set_expression(Expression* e) { expression_ = e; }
933 WithStatement(Scope* scope, Expression* expression, Statement* statement,
937 expression_(expression),
941 Expression* expression_;
946 class CaseClause final : public Expression {
949 Expression* label() const {
953 void set_label(Expression* e) { label_ = e; }
975 static int parent_num_ids() { return Expression::num_ids(); }
976 CaseClause(Expression* label, ZoneList<Statement*>* statements, int pos);
979 Expression* label_;
989 void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
994 Expression* tag() const { return tag_; }
997 void set_tag(Expression* t) { tag_ = t; }
1007 Expression* tag_;
1022 Expression* condition() const { return condition_; }
1026 void set_condition(Expression* e) { condition_ = e; }
1044 IfStatement(Expression* condition, Statement* then_statement,
1060 Expression* condition_;
1192 class Literal final : public Expression {
1228 : Expression(position, kLiteral), value_(value) {}
1230 static int parent_num_ids() { return Expression::num_ids(); }
1237 class MaterializedLiteral : public Expression {
1257 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
1261 : Expression(pos, type), depth_(0) {
1286 // If the expression is a literal, return the literal value;
1287 // if the expression is a materialized literal and is simple return a
1291 Handle<Object> GetBoilerplateValue(Expression* expression, Isolate* isolate);
1299 Expression* key() const { return key_; }
1300 Expression* value() const { return value_; }
1301 void set_key(Expression* e) { key_ = e; }
1302 void set_value(Expression* e) { value_ = e; }
1323 LiteralProperty(Expression* key, Expression* value, bool is_computed_name)
1326 Expression* key_;
1327 Expression* value_;
1363 ObjectLiteralProperty(Expression* key, Expression* value, Kind kind,
1365 ObjectLiteralProperty(AstValueFactory* ast_value_factory, Expression* key,
1366 Expression* value, bool is_computed_name);
1552 ZoneList<Expression*>* values() const { return values_; }
1590 ZoneList<Expression*>::iterator FirstSpread() const {
1594 Expression*>::iterator EndValue() const { return values_->end(); }
1612 ArrayLiteral(ZoneList<Expression*>* values, int first_spread_index, int pos)
1623 ZoneList<Expression*>* values_;
1627 class VariableProxy final : public Expression {
1701 static int parent_num_ids() { return Expression::num_ids(); }
1704 class IsThisField : public BitField<bool, Expression::kNextBitFieldIndex, 1> {
1732 class Property final : public Expression {
1736 Expression* obj() const { return obj_; }
1737 Expression* key() const { return key_; }
1739 void set_obj(Expression* e) { obj_ = e; }
1740 void set_key(Expression* e) { key_ = e; }
1802 Property(Expression* obj, Expression* key, int pos)
1803 : Expression(pos, kProperty), obj_(obj), key_(key) {
1809 static int parent_num_ids() { return Expression::num_ids(); }
1813 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
1822 Expression* obj_;
1823 Expression* key_;
1828 class Call final : public Expression {
1830 Expression* expression() const { return expression_; }
1831 ZoneList<Expression*>* arguments() const { return arguments_; }
1833 void set_expression(Expression* e) { expression_ = e; }
1842 if (expression()->IsProperty()) {
1843 return expression()->AsProperty()->GetReceiverTypes();
1849 if (expression()->IsProperty()) {
1850 return expression()->AsProperty()->IsMonomorphic();
1920 Call(Expression* expression, ZoneList<Expression*>* arguments, int pos,
1922 : Expression(pos, kCall),
1923 expression_(expression),
1929 if (expression->IsProperty()) {
1930 expression->AsProperty()->mark_for_call();
1934 static int parent_num_ids() { return Expression::num_ids(); }
1938 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
1943 Expression* expression_;
1944 ZoneList<Expression*>* arguments_;
1950 class CallNew final : public Expression {
1952 Expression* expression() const { return expression_; }
1953 ZoneList<Expression*>* arguments() const { return arguments_; }
1955 void set_expression(Expression* e) { expression_ = e; }
1999 CallNew(Expression* expression, ZoneList<Expression*>* arguments, int pos)
2000 : Expression(pos, kCallNew),
2001 expression_(expression),
2006 static int parent_num_ids() { return Expression::num_ids(); }
2010 Expression* expression_;
2011 ZoneList<Expression*>* arguments_;
2016 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2024 class CallRuntime final : public Expression {
2026 ZoneList<Expression*>* arguments() const { return arguments_; }
2050 ZoneList<Expression*>* arguments, int pos)
2051 : Expression(pos, kCallRuntime),
2054 CallRuntime(int context_index, ZoneList<Expression*>* arguments, int pos)
2055 : Expression(pos, kCallRuntime),
2060 static int parent_num_ids() { return Expression::num_ids(); }
2065 ZoneList<Expression*>* arguments_;
2069 class UnaryOperation final : public Expression {
2072 Expression* expression() const { return expression_; }
2073 void set_expression(Expression* e) { expression_ = e; }
2086 UnaryOperation(Token::Value op, Expression* expression, int pos)
2087 : Expression(pos, kUnaryOperation), expression_(expression) {
2092 static int parent_num_ids() { return Expression::num_ids(); }
2095 Expression* expression_;
2098 : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
2102 class BinaryOperation final : public Expression {
2105 Expression
2106 void set_left(Expression* e) { left_ = e; }
2107 Expression* right() const { return right_; }
2108 void set_right(Expression* e) { right_ = e; }
2154 BinaryOperation(Token::Value op, Expression* left, Expression* right, int pos)
2155 : Expression(pos, kBinaryOperation),
2164 static int parent_num_ids() { return Expression::num_ids(); }
2171 Expression* left_;
2172 Expression* right_;
2177 : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
2181 class CountOperation final : public Expression {
2191 Expression* expression() const { return expression_; }
2192 void set_expression(Expression* e) { expression_ = e; }
2231 CountOperation(Token::Value op, bool is_prefix, Expression* expr, int pos)
2232 : Expression(pos, kCountOperation), type_(NULL), expression_(expr) {
2238 static int parent_num_ids() { return Expression::num_ids(); }
2242 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2251 Expression* expression_;
2256 class CompareOperation final : public Expression {
2259 Expression* left() const { return left_; }
2260 Expression* right() const { return right_; }
2262 void set_left(Expression* e) { left_ = e; }
2263 void set_right(Expression* e) { right_ = e; }
2282 bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
2283 bool IsLiteralCompareUndefined(Expression** expr);
2284 bool IsLiteralCompareNull(Expression** expr);
2289 CompareOperation(Token::Value op, Expression* left, Expression* right,
2291 : Expression(pos, kCompareOperation),
2299 static int parent_num_ids() { return Expression::num_ids(); }
2302 Expression* left_;
2303 Expression* right_;
2308 : public BitField<Token::Value, Expression::kNextBitFieldIndex, 7> {};
2312 class Spread final : public Expression {
2314 Expression* expression() const { return expression_; }
2315 void set_expression(Expression* e) { expression_ = e; }
2324 Spread(Expression* expression, int pos, int expr_pos)
2325 : Expression(pos, kSpread),
2327 expression_(expression) {}
2329 static int parent_num_ids() { return Expression::num_ids(); }
2333 Expression* expression_;
2337 class Conditional final : public Expression {
2339 Expression* condition() const { return condition_; }
2340 Expression* then_expression() const { return then_expression_; }
2341 Expression* else_expression() const { return else_expression_; }
2343 void set_condition(Expression* e) { condition_ = e; }
2344 void set_then_expression(Expression* e) { then_expression_ = e; }
2345 void set_else_expression(Expression* e) { else_expression_ = e; }
2359 Conditional(Expression* condition, Expression* then_expression,
2360 Expression* else_expression, int position)
2361 : Expression(position, kConditional),
2366 static int parent_num_ids() { return Expression::num_ids(); }
2369 Expression* condition_;
2370 Expression* then_expression_;
2371 Expression* else_expression_;
2375 class Assignment final : public Expression {
2382 Expression* target() const { return target_; }
2383 Expression* value() const { return value_; }
2385 void set_target(Expression* e) { target_ = e; }
2386 void set_value(Expression* e) { value_ = e; }
2427 Assignment(Token::Value op, Expression* target, Expression* value, int pos);
2429 static int parent_num_ids() { return Expression::num_ids(); }
2433 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2441 Expression* target_;
2442 Expression* value_;
2463 class RewritableExpression final : public Expression {
2465 Expression* expression() const { return expr_; }
2468 void Rewrite(Expression* new_expression) {
2481 explicit RewritableExpression(Expression* expression)
2482 : Expression(expression->position(), kRewritableExpression),
2483 expr_(expression) {
2485 DCHECK(!expression->IsRewritableExpression());
2490 Expression* expr_;
2493 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2499 class Yield final : public Expression {
2503 Expression* generator_object() const { return generator_object_; }
2504 Expression* expression() const { return expression_; }
2513 void set_generator_object(Expression* e) { generator_object_ = e; }
2514 void set_expression(Expression* e) { expression_ = e; }
2520 Yield(Expression* generator_object, Expression* expression, int pos,
2522 : Expression(pos, kYield),
2525 expression_(expression) {
2530 Expression* generator_object_;
2531 Expression* expression_;
2534 : public BitField<OnException, Expression::kNextBitFieldIndex, 1> {};
2538 class Throw final : public Expression {
2540 Expression* exception() const { return exception_; }
2541 void set_exception(Expression* e) { exception_ = e; }
2546 Throw(Expression* exception, int pos)
2547 : Expression(pos, kThrow), exception_(exception) {}
2549 Expression* exception_;
2553 class FunctionLiteral final : public Expression {
2594 static bool NeedsHomeObject(Expression* expr);
2708 : Expression(position, kFunctionLiteral),
2731 : public BitField<FunctionType, Expression::kNextBitFieldIndex, 2> {};
2770 ClassLiteralProperty(Expression* key, Expression* value, Kind kind,
2777 class ClassLiteral final : public Expression {
2782 Expression* extends() const { return extends_; }
2783 void set_extends(Expression* e) { extends_ = e; }
2812 ClassLiteral(VariableProxy* class_variable_proxy, Expression* extends,
2816 : Expression(start_position, kClassLiteral),
2830 Expression* extends_;
2835 : public BitField<bool, Expression::kNextBitFieldIndex, 1> {};
2841 class NativeFunctionLiteral final : public Expression {
2859 : Expression(pos, kNativeFunctionLiteral),
2869 class ThisFunction final : public Expression {
2872 explicit ThisFunction(int pos) : Expression(pos, kThisFunction) {}
2876 class SuperPropertyReference final : public Expression {
2880 Expression* home_object() const { return home_object_; }
2881 void set_home_object(Expression* e) { home_object_ = e; }
2886 SuperPropertyReference(VariableProxy* this_var, Expression* home_object,
2888 : Expression(pos, kSuperPropertyReference),
2896 Expression* home_object_;
2900 class SuperCallReference final : public Expression {
2914 : Expression(pos, kSuperCallReference),
2930 // arguments and is not actually a valid expression.
2931 class EmptyParentheses final : public Expression {
2935 explicit EmptyParentheses(int pos) : Expression(pos, kEmptyParentheses) {}
2943 class GetIterator final : public Expression {
2947 Expression* iterable() const { return iterable_; }
2948 void set_iterable(Expression* iterable) { iterable_ = iterable; }
2981 explicit GetIterator(Expression* iterable, IteratorType hint, int pos)
2982 : Expression(pos, kGetIterator), hint_(hint), iterable_(iterable) {}
2985 Expression* iterable_;
3014 void VisitExpressions(ZoneList<Expression*>* expressions) {
3018 // undefined expression or literal? Revisit this code if this
3020 Expression* expression = expressions->at(i);
3021 if (expression != NULL) Visit(expression);
3110 // Generic macro for rewriting things; `GET` is the expression to be
3210 ExpressionStatement* NewExpressionStatement(Expression* expression, int pos) {
3211 return new (zone_) ExpressionStatement(expression, pos);
3222 ReturnStatement* NewReturnStatement(Expression* expression, int pos) {
3224 ReturnStatement(expression, ReturnStatement::kNormal, pos);
3227 ReturnStatement* NewAsyncReturnStatement(Expression* expression, int pos) {
3229 ReturnStatement(expression, ReturnStatement::kAsyncReturn, pos);
3233 Expression* expression,
3236 return new (zone_) WithStatement(scope, expression, statement, pos);
3239 IfStatement* NewIfStatement(Expression* condition,
3301 Expression* label, ZoneList<Statement*>* statements, int pos) {
3347 Expression* key, Expression* value, ObjectLiteralProperty::Kind kind,
3353 ObjectLiteral::Property* NewObjectLiteralProperty(Expression* key,
3354 Expression* value,
3365 ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
3370 ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
3392 Property* NewProperty(Expression* obj, Expression* key, int pos) {
3396 Call* NewCall(Expression* expression, ZoneList<Expression*>* arguments,
3398 return new (zone_) Call(expression, arguments, pos, possibly_eval);
3401 CallNew* NewCallNew(Expression* expression,
3402 ZoneList<Expression*>* arguments,
3404 return new (zone_) CallNew(expression, arguments, pos);
3408 ZoneList<Expression*>* arguments, int pos) {
3413 ZoneList<Expression*>* arguments, int pos) {
3418 Expression*>* arguments, int pos) {
3423 Expression* expression,
3425 return new (zone_) UnaryOperation(op, expression, pos);
3429 Expression* left,
3430 Expression* right,
3437 Expression* expr,
3443 Expression* left,
3444 Expression* right,
3449 Spread* NewSpread(Expression* expression, int pos, int expr_pos) {
3450 return new (zone_) Spread(expression, pos, expr_pos);
3453 Conditional* NewConditional(Expression* condition,
3454 Expression* then_expression,
3455 Expression* else_expression,
3461 RewritableExpression* NewRewritableExpression(Expression* expression) {
3462 DCHECK_NOT_NULL(expression);
3463 return new (zone_) RewritableExpression(expression);
3467 Expression* target,
3468 Expression* value,
3484 Yield* NewYield(Expression* generator_object, Expression* expression, int pos,
3486 if (!expression) expression = NewUndefinedLiteral(pos);
3487 return new (zone_) Yield(generator_object, expression, pos, on_exception);
3490 Throw* NewThrow(Expression* exception, int pos) {
3526 Expression* key, Expression* value, ClassLiteralProperty::Kind kind,
3532 ClassLiteral* NewClassLiteral(VariableProxy* proxy, Expression* extends,
3559 Expression* home_object,
3576 GetIterator* NewGetIterator(Expression* iterable, IteratorType hint,
3621 ->expression() \
3631 reinterpret_cast<const RewritableExpression*>(this)->expression(); \
3642 reinterpret_cast<const RewritableExpression*>(this)->expression(); \
