Lines Matching defs:Expression
111 class Expression;
301 class Expression : public AstNode {
330 // True iff the expression is a literal represented as a smi.
333 // True iff the expression is a string literal.
336 // True iff the expression is the null literal.
339 // True if we can prove that the expression is the undefined literal.
342 // Expression type bounds
368 Expression(Zone* zone, int pos)
755 void Initialize(Expression* cond, Statement* body) {
760 Expression* cond() const { return cond_; }
775 Expression* cond_;
786 void Initialize(Expression* cond, Statement* body) {
791 Expression* cond() const { return cond_; }
812 Expression* cond_;
826 Expression* cond,
836 Expression* cond() const { return cond_; }
868 Expression* cond_;
887 void Initialize(Expression* each, Expression* subject, Statement* body) {
893 Expression* each() const { return each_; }
894 Expression* subject() const { return subject_; }
904 Expression* each_;
905 Expression* subject_;
914 Expression* enumerable() const {
956 void Initialize(Expression* each,
957 Expression* subject,
959 Expression* assign_iterable,
960 Expression* assign_iterator,
961 Expression* next_result,
962 Expression* result_done,
963 Expression* assign_each) {
972 Expression* iterable() const {
977 Expression* assign_iterable() const {
982 Expression* assign_iterator() const {
987 Expression* next_result() const {
992 Expression* result_done() const {
997 Expression* assign_each() const {
1016 Expression* assign_iterable_;
1017 Expression* assign_iterator_;
1018 Expression* next_result_;
1019 Expression* result_done_;
1020 Expression* assign_each_;
1029 void set_expression(Expression* e) { expression_ = e; }
1030 Expression* expression() const { return expression_; }
1034 ExpressionStatement(Zone* zone, Expression* expression, int pos)
1035 : Statement(zone, pos), expression_(expression) { }
1038 Expression* expression_;
1085 Expression* expression() const { return expression_; }
1088 explicit ReturnStatement(Zone* zone, Expression* expression, int pos)
1089 : JumpStatement(zone, pos), expression_(expression) { }
1092 Expression* expression_;
1101 Expression* expression() const { return expression_; }
1107 Expression* expression, Statement* statement, int pos)
1110 expression_(expression),
1115 Expression* expression_;
1120 class CaseClause V8_FINAL : public Expression {
1125 Expression* label() const {
1141 Expression* label,
1145 Expression* label_;
1159 void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
1164 Expression* tag() const { return tag_; }
1174 Expression* tag_;
1191 Expression* condition() const { return condition_; }
1206 Expression* condition,
1220 Expression* condition_;
1343 class Literal V8_FINAL : public Expression {
1383 : Expression(zone, position),
1397 class MaterializedLiteral : public Expression {
1413 : Expression(zone, pos),
1434 // If the expression is a literal, return the literal value;
1435 // if the expression is a materialized literal and is simple return a
1439 Handle<Object> GetBoilerplateValue(Expression* expression, Isolate* isolate);
1461 ObjectLiteralProperty(Zone* zone, Literal* key, Expression* value);
1464 Expression* value() { return value_; }
1485 Expression* value_;
1527 Expression* getter;
1528 Expression* setter;
1588 ZoneList<Expression*>* values() const { return values_; }
1606 ZoneList<Expression*>* values,
1615 ZoneList<Expression*>* values_;
1620 class VariableProxy V8_FINAL : public Expression {
1668 class Property V8_FINAL : public Expression {
1674 Expression* obj() const { return obj_; }
1675 Expression* key() const { return key_; }
1706 Expression* obj,
1707 Expression* key,
1709 : Expression(zone, pos),
1719 Expression* obj_;
1720 Expression* key_;
1731 class Call V8_FINAL : public Expression, public FeedbackSlotInterface {
1735 Expression* expression() const { return expression_; }
1736 ZoneList<Expression*>* arguments() const { return arguments_; }
1750 if (expression()->IsProperty()) {
1751 return expression()->AsProperty()->GetReceiverTypes();
1757 if (expression()->IsProperty()) {
1758 return expression()->AsProperty()->IsMonomorphic();
1805 Expression* expression,
1806 ZoneList<Expression*>* arguments,
1808 : Expression(zone, pos),
1809 expression_(expression),
1813 if (expression->IsProperty()) {
1814 expression->AsProperty()->mark_for_call();
1819 Expression* expression_;
1820 ZoneList<Expression*>* arguments_;
1831 class CallNew V8_FINAL : public Expression, public FeedbackSlotInterface {
1835 Expression* expression() const { return expression_; }
1836 ZoneList<Expression*>* arguments() const { return arguments_; }
1870 Expression* expression,
1871 ZoneList<Expression*>* arguments,
1873 : Expression(zone, pos),
1874 expression_(expression),
1882 Expression* expression_;
1883 ZoneList<Expression*>* arguments_;
1899 class CallRuntime V8_FINAL : public Expression {
1905 ZoneList<Expression*>* arguments() const { return arguments_; }
1914 ZoneList<Expression*>* arguments,
1916 : Expression(zone, pos),
1924 ZoneList<Expression*>* arguments_;
1928 class UnaryOperation V8_FINAL : public Expression {
1933 Expression* expression() const { return expression_; }
1944 Expression* expression,
1946 : Expression(zone, pos),
1948 expression_(expression),
1956 Expression* expression_;
1965 class BinaryOperation V8_FINAL : public Expression {
1972 Expression* left() const { return left_; }
1973 Expression* right() const { return right_; }
1991 Expression* left,
1992 Expression* right,
1994 : Expression(zone, pos),
2004 Expression* left_;
2005 Expression* right_;
2018 class CountOperation V8_FINAL : public Expression {
2030 Expression* expression() const { return expression_; }
2054 Expression* expr,
2056 : Expression(zone, pos),
2071 Expression* expression_;
2078 class CompareOperation V8_FINAL : public Expression {
2083 Expression* left() const { return left_; }
2084 Expression* right() const { return right_; }
2092 bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
2093 bool IsLiteralCompareUndefined(Expression** expr, Isolate* isolate);
2094 bool IsLiteralCompareNull(Expression** expr);
2099 Expression* left,
2100 Expression* right,
2102 : Expression(zone, pos),
2112 Expression* left_;
2113 Expression* right_;
2119 class Conditional V8_FINAL : public Expression {
2123 Expression* condition() const { return condition_; }
2124 Expression* then_expression() const { return then_expression_; }
2125 Expression* else_expression() const { return else_expression_; }
2132 Expression* condition,
2133 Expression* then_expression,
2134 Expression* else_expression,
2136 : Expression(zone, position),
2144 Expression* condition_;
2145 Expression* then_expression_;
2146 Expression* else_expression_;
2152 class Assignment V8_FINAL : public Expression {
2161 Expression* target() const { return target_; }
2162 Expression* value() const { return value_; }
2191 Expression* target,
2192 Expression* value,
2206 Expression* target_;
2207 Expression* value_;
2218 class Yield V8_FINAL : public Expression {
2224 SUSPEND, // A normal yield: { value: EXPRESSION, done: false }
2226 FINAL // A return: { value: EXPRESSION, done: true }
2229 Expression* generator_object() const { return generator_object_; }
2230 Expression* expression() const { return expression_; }
2247 Expression* generator_object,
2248 Expression* expression,
2251 : Expression(zone, pos),
2253 expression_(expression),
2258 Expression* generator_object_;
2259 Expression* expression_;
2265 class Throw V8_FINAL : public Expression {
2269 Expression* exception() const { return exception_; }
2272 Throw(Zone* zone, Expression* exception, int pos)
2273 : Expression(zone, pos), exception_(exception) {}
2276 Expression* exception_;
2280 class FunctionLiteral V8_FINAL : public Expression {
2405 : Expression(zone, position),
2452 class NativeFunctionLiteral V8_FINAL : public Expression {
2462 : Expression(zone, pos), name_(name), extension_(extension) {}
2470 class ThisFunction V8_FINAL : public Expression {
2475 explicit ThisFunction(Zone* zone, int pos): Expression(zone, pos) {}
2508 // expression.
2863 virtual void VisitExpressions(ZoneList<Expression*>* expressions);
3074 ExpressionStatement* NewExpressionStatement(Expression* expression, int pos) {
3076 new(zone_) ExpressionStatement(zone_, expression, pos);
3090 ReturnStatement* NewReturnStatement(Expression* expression, int pos) {
3091 ReturnStatement* stmt = new(zone_) ReturnStatement(zone_, expression, pos);
3096 Expression* expression,
3100 zone_, scope, expression, statement, pos);
3104 IfStatement* NewIfStatement(Expression* condition,
3143 Expression* label, ZoneList<Statement*>* statements, int pos) {
3172 Expression* value) {
3194 ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
3217 Property* NewProperty(Expression* obj, Expression* key, int pos) {
3222 Call* NewCall(Expression* expression,
3223 ZoneList<Expression*>* arguments,
3225 Call* call = new(zone_) Call(zone_, expression, arguments, pos);
3229 CallNew* NewCallNew(Expression* expression,
3230 ZoneList<Expression*>* arguments,
3232 CallNew* call = new(zone_) CallNew(zone_, expression, arguments, pos);
3238 Expression*>* arguments,
3246 Expression* expression,
3249 new(zone_) UnaryOperation(zone_, op, expression, pos);
3254 Expression* left,
3255 Expression* right,
3264 Expression* expr,
3272 Expression* left,
3273 Expression* right,
3280 Conditional* NewConditional(Expression* condition,
3281 Expression* then_expression,
3282 Expression* else_expression,
3290 Expression* target,
3291 Expression* value,
3299 Yield* NewYield(Expression *generator_object,
3300 Expression* expression,
3304 zone_, generator_object, expression, yield_kind, pos);
3308 Throw* NewThrow(Expression* exception, int pos) {
