Lines Matching full:expression
137 class Expression;
317 class Expression : public AstNode {
346 // True iff the expression is a literal represented as a smi.
349 // True iff the expression is a string literal.
352 // True iff the expression is the null literal.
355 // True if we can prove that the expression is the undefined literal.
358 // Expression type bounds
384 Expression(Isolate* isolate, int pos)
763 void Initialize(Expression* cond, Statement* body) {
768 Expression* cond() const { return cond_; }
783 Expression* cond_;
794 void Initialize(Expression* cond, Statement* body) {
799 Expression* cond() const { return cond_; }
820 Expression* cond_;
834 Expression* cond,
844 Expression* cond() const { return cond_; }
876 Expression* cond_;
895 void Initialize(Expression* each, Expression* subject, Statement* body) {
901 Expression* each() const { return each_; }
902 Expression* subject() const { return subject_; }
912 Expression* each_;
913 Expression* subject_;
921 Expression* enumerable() const {
953 void Initialize(Expression* each,
954 Expression* subject,
956 Expression* assign_iterator,
957 Expression* next_result,
958 Expression* result_done,
959 Expression* assign_each) {
967 Expression* iterable() const {
972 Expression* assign_iterator() const {
977 Expression* next_result() const {
982 Expression* result_done() const {
987 Expression* assign_each() const {
1006 Expression* assign_iterator_;
1007 Expression* next_result_;
1008 Expression* result_done_;
1009 Expression* assign_each_;
1018 void set_expression(Expression* e) { expression_ = e; }
1019 Expression* expression() const { return expression_; }
1023 ExpressionStatement(Expression* expression, int pos)
1024 : Statement(pos), expression_(expression) { }
1027 Expression* expression_;
1074 Expression* expression() const { return expression_; }
1077 explicit ReturnStatement(Expression* expression, int pos)
1078 : JumpStatement(pos), expression_(expression) { }
1081 Expression* expression_;
1090 Expression* expression() const { return expression_; }
1095 Scope* scope, Expression* expression, Statement* statement, int pos)
1098 expression_(expression),
1103 Expression* expression_;
1113 Expression* label() const {
1129 Expression* label,
1133 Expression* label_;
1147 void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
1153 Expression* tag() const { return tag_; }
1167 Expression* tag_;
1185 Expression
1200 Expression* condition,
1214 Expression* condition_;
1336 class Literal V8_FINAL : public Expression {
1391 : Expression(isolate, position),
1405 class MaterializedLiteral : public Expression {
1421 : Expression(isolate, pos),
1442 // If the expression is a literal, return the literal value;
1443 // if the expression is a materialized literal and is simple return a
1447 Handle<Object> GetBoilerplateValue(Expression* expression, Isolate* isolate);
1469 ObjectLiteralProperty(Literal* key, Expression* value, Isolate* isolate);
1472 Expression* value() { return value_; }
1493 Expression* value_;
1535 Expression* getter;
1536 Expression* setter;
1596 ZoneList<Expression*>* values() const { return values_; }
1614 ZoneList<Expression*>* values,
1623 ZoneList<Expression*>* values_;
1628 class VariableProxy V8_FINAL : public Expression {
1678 class Property V8_FINAL : public Expression {
1684 Expression* obj() const { return obj_; }
1685 Expression* key() const { return key_; }
1716 Expression* obj,
1717 Expression* key,
1719 : Expression(isolate, pos),
1729 Expression* obj_;
1730 Expression* key_;
1741 class Call V8_FINAL : public Expression {
1745 Expression* expression() const { return expression_; }
1746 ZoneList<Expression*>* arguments() const { return arguments_; }
1799 Expression* expression,
1800 ZoneList<Expression*>* arguments,
1802 : Expression(isolate, pos),
1803 expression_(expression),
1811 Expression* expression_;
1812 ZoneList<Expression*>* arguments_;
1826 class CallNew V8_FINAL : public Expression {
1830 Expression* expression() const { return expression_; }
1831 ZoneList<Expression*>* arguments() const { return arguments_; }
1847 Expression* expression,
1848 ZoneList<Expression*>* arguments,
1850 : Expression(isolate, pos),
1851 expression_(expression),
1858 Expression* expression_;
1859 ZoneList<Expression*>* arguments_;
1874 class CallRuntime V8_FINAL : public Expression {
1880 ZoneList<Expression*>* arguments() const { return arguments_; }
1889 ZoneList<Expression*>* arguments,
1891 : Expression(isolate, pos),
1899 ZoneList<Expression*>* arguments_;
1903 class UnaryOperation V8_FINAL : public Expression {
1908 Expression* expression() const { return expression_; }
1919 Expression* expression,
1921 : Expression(isolate, pos),
1923 expression_(expression),
1931 Expression* expression_;
1940 class BinaryOperation V8_FINAL : public Expression {
1947 Expression* left() const { return left_; }
1948 Expression* right() const { return right_; }
1962 Expression* left,
1963 Expression* right,
1965 : Expression(isolate, pos),
1975 Expression* left_;
1976 Expression* right_;
1988 class CountOperation V8_FINAL : public Expression {
2000 Expression* expression() const { return expression_; }
2024 Expression* expr,
2026 : Expression(isolate, pos),
2041 Expression* expression_;
2048 class CompareOperation V8_FINAL : public Expression {
2053 Expression* left() const { return left_; }
2054 Expression* right() const { return right_; }
2062 bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
2063 bool IsLiteralCompareUndefined(Expression** expr, Isolate* isolate);
2064 bool IsLiteralCompareNull(Expression** expr);
2069 Expression* left,
2070 Expression* right,
2072 : Expression(isolate, pos),
2082 Expression* left_;
2083 Expression* right_;
2089 class Conditional V8_FINAL : public Expression {
2093 Expression* condition() const { return condition_; }
2094 Expression* then_expression() const { return then_expression_; }
2095 Expression* else_expression() const { return else_expression_; }
2102 Expression* condition,
2103 Expression* then_expression,
2104 Expression* else_expression,
2106 : Expression(isolate, position),
2114 Expression* condition_;
2115 Expression* then_expression_;
2116 Expression* else_expression_;
2122 class Assignment V8_FINAL : public Expression {
2131 Expression* target() const { return target_; }
2132 Expression* value() const { return value_; }
2163 Expression* target,
2164 Expression* value,
2178 Expression* target_;
2179 Expression* value_;
2191 class Yield V8_FINAL : public Expression {
2197 SUSPEND, // A normal yield: { value: EXPRESSION, done: false }
2199 FINAL // A return: { value: EXPRESSION, done: true }
2202 Expression* generator_object() const { return generator_object_; }
2203 Expression* expression() const { return expression_; }
2220 Expression* generator_object,
2221 Expression* expression,
2224 : Expression(isolate, pos),
2226 expression_(expression),
2231 Expression* generator_object_;
2232 Expression* expression_;
2238 class Throw V8_FINAL : public Expression {
2242 Expression* exception() const { return exception_; }
2245 Throw(Isolate* isolate, Expression* exception, int pos)
2246 : Expression(isolate, pos), exception_(exception) {}
2249 Expression* exception_;
2253 class FunctionLiteral V8_FINAL : public Expression {
2366 : Expression(isolate, position),
2412 class NativeFunctionLiteral V8_FINAL : public Expression {
2422 : Expression(isolate, pos), name_(name), extension_(extension) {}
2430 class ThisFunction V8_FINAL : public Expression {
2435 explicit ThisFunction(Isolate* isolate, int pos): Expression(isolate, pos) {}
2468 // expression.
2823 virtual void VisitExpressions(ZoneList<Expression*>* expressions);
3026 ExpressionStatement* NewExpressionStatement(Expression* expression, int pos) {
3027 ExpressionStatement* stmt = new(zone_) ExpressionStatement(expression, pos);
3041 ReturnStatement* NewReturnStatement(Expression* expression, int pos) {
3042 ReturnStatement* stmt = new(zone_) ReturnStatement(expression, pos);
3047 Expression* expression,
3051 scope, expression, statement, pos);
3055 IfStatement* NewIfStatement(Expression* condition,
3094 Expression* label, ZoneList<Statement*>* statements, int pos) {
3139 ArrayLiteral* NewArrayLiteral(ZoneList<Expression*>* values,
3162 Property* NewProperty(Expression* obj, Expression* key, int pos) {
3167 Call* NewCall(Expression* expression,
3168 ZoneList<Expression*>* arguments,
3170 Call* call = new(zone_) Call(isolate_, expression, arguments, pos);
3174 CallNew* NewCallNew(Expression* expression,
3175 ZoneList<Expression*>* arguments,
3177 CallNew* call = new(zone_) CallNew(isolate_, expression, arguments, pos);
3183 ZoneList<Expression*>* arguments,
3191 Expression* expression,
3194 new(zone_) UnaryOperation(isolate_, op, expression, pos);
3199 Expression* left,
3200 Expression* right,
3209 Expression* expr,
3217 Expression* left,
3218 Expression* right,
3225 Conditional* NewConditional(Expression* condition,
3226 Expression* then_expression,
3227 Expression* else_expression,
3235 Expression* target,
3236 Expression* value,
3244 Yield* NewYield(Expression *generator_object,
3245 Expression* expression,
3249 isolate_, generator_object, expression, yield_kind, pos);
3253 Throw* NewThrow(Expression* exception, int pos) {
