Lines Matching defs:Expression
137 class Expression;
313 class Expression: public AstNode {
347 // True iff the expression is a literal represented as a smi.
350 // True iff the expression is a string literal.
353 // True iff the expression is the null literal.
356 // True if we can prove that the expression is the undefined literal.
359 // Expression type bounds
391 explicit Expression(Isolate* isolate)
752 void Initialize(Expression* cond, Statement* body) {
757 Expression* cond() const { return cond_; }
759 // Position where condition expression starts. We need it to make
778 Expression* cond_;
791 void Initialize(Expression* cond, Statement* body) {
796 Expression* cond() const { return cond_; }
817 Expression* cond_;
831 Expression* cond,
841 Expression* cond() const { return cond_; }
873 Expression* cond_;
892 void Initialize(Expression* each, Expression* subject, Statement* body) {
898 Expression* each() const { return each_; }
899 Expression* subject() const { return subject_; }
909 Expression* each_;
910 Expression* subject_;
918 Expression* enumerable() const {
950 void Initialize(Expression* each,
951 Expression* subject,
953 Expression* assign_iterator,
954 Expression* next_result,
955 Expression* result_done,
956 Expression* assign_each) {
964 Expression* iterable() const {
969 Expression* assign_iterator() const {
974 Expression* next_result() const {
979 Expression* result_done() const {
984 Expression* assign_each() const {
1003 Expression* assign_iterator_;
1004 Expression* next_result_;
1005 Expression* result_done_;
1006 Expression* assign_each_;
1015 void set_expression(Expression* e) { expression_ = e; }
1016 Expression* expression() const { return expression_; }
1020 explicit ExpressionStatement(Expression* expression)
1021 : expression_(expression) { }
1024 Expression* expression_;
1071 Expression* expression() const { return expression_; }
1074 explicit ReturnStatement(Expression* expression)
1075 : expression_(expression) { }
1078 Expression* expression_;
1087 Expression* expression() const { return expression_; }
1091 WithStatement(Scope* scope, Expression* expression, Statement* statement)
1093 expression_(expression),
1098 Expression* expression_;
1106 Expression* label,
1111 Expression* label() const {
1129 Expression* label_;
1144 void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
1150 Expression* tag() const { return tag_; }
1164 Expression* tag_;
1182 Expression* condition() const { return condition_; }
1197 Expression* condition,
1209 Expression* condition_;
1327 class Literal: public Expression {
1377 : Expression(isolate),
1388 class MaterializedLiteral: public Expression {
1405 : Expression(isolate),
1430 ObjectLiteralProperty(Literal* key, Expression* value, Isolate* isolate);
1433 Expression* value() { return value_; }
1454 Expression* value_;
1490 Expression* getter;
1491 Expression* setter;
1549 ZoneList<Expression*>* values() const { return values_; }
1559 ZoneList<Expression*>* values,
1570 ZoneList<Expression*>* values_;
1575 class VariableProxy: public Expression {
1627 class Property: public Expression {
1633 Expression* obj() const { return obj_; }
1634 Expression* key() const { return key_; }
1655 Expression* obj,
1656 Expression* key,
1658 : Expression(isolate),
1670 Expression* obj_;
1671 Expression* key_;
1684 class Call: public Expression {
1688 Expression* expression() const { return expression_; }
1689 ZoneList<Expression*>* arguments() const { return arguments_; }
1740 Expression* expression,
1741 ZoneList<Expression*>* arguments,
1743 : Expression(isolate),
1744 expression_(expression),
1752 Expression* expression_;
1753 ZoneList<Expression*>* arguments_;
1767 class CallNew: public Expression {
1771 Expression* expression() const { return expression_; }
1772 ZoneList<Expression*>* arguments() const { return arguments_; }
1789 Expression* expression,
1790 ZoneList<Expression*>* arguments,
1792 : Expression(isolate),
1793 expression_(expression),
1801 Expression* expression_;
1802 ZoneList<Expression*>* arguments_;
1818 class CallRuntime: public Expression {
1824 ZoneList<Expression*>* arguments() const { return arguments_; }
1833 ZoneList<Expression*>* arguments)
1834 : Expression(isolate),
1842 ZoneList<Expression*>* arguments_;
1846 class UnaryOperation: public Expression {
1851 Expression* expression() const { return expression_; }
1862 Expression* expression,
1864 : Expression(isolate),
1866 expression_(expression),
1875 Expression* expression_;
1885 class BinaryOperation: public Expression {
1892 Expression* left() const { return left_; }
1893 Expression* right() const { return right_; }
1907 Expression* left,
1908 Expression* right,
1910 : Expression(isolate),
1921 Expression* left_;
1922 Expression* right_;
1935 class CountOperation: public Expression {
1947 Expression* expression() const { return expression_; }
1969 Expression* expr,
1971 : Expression(isolate),
1989 Expression* expression_;
1997 class CompareOperation: public Expression {
2002 Expression* left() const { return left_; }
2003 Expression* right() const { return right_; }
2012 bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
2013 bool IsLiteralCompareUndefined(Expression** expr, Isolate* isolate);
2014 bool IsLiteralCompareNull(Expression** expr);
2019 Expression* left,
2020 Expression* right,
2022 : Expression(isolate),
2032 Expression* left_;
2033 Expression* right_;
2040 class Conditional: public Expression {
2044 Expression* condition() const { return condition_; }
2045 Expression* then_expression() const { return then_expression_; }
2046 Expression* else_expression() const { return else_expression_; }
2056 Expression* condition,
2057 Expression* then_expression,
2058 Expression* else_expression,
2061 : Expression(isolate),
2071 Expression* condition_;
2072 Expression* then_expression_;
2073 Expression* else_expression_;
2081 class Assignment: public Expression {
2090 Expression* target() const { return target_; }
2091 Expression* value() const { return value_; }
2113 Expression* target,
2114 Expression* value,
2128 Expression* target_;
2129 Expression* value_;
2142 class Yield: public Expression {
2148 SUSPEND, // A normal yield: { value: EXPRESSION, done: false }
2150 FINAL // A return: { value: EXPRESSION, done: true }
2153 Expression* generator_object() const { return generator_object_; }
2154 Expression* expression() const { return expression_; }
2172 Expression* generator_object,
2173 Expression* expression,
2176 : Expression(isolate),
2178 expression_(expression),
2184 Expression* generator_object_;
2185 Expression* expression_;
2192 class Throw: public Expression {
2196 Expression* exception() const { return exception_; }
2200 Throw(Isolate* isolate, Expression* exception, int pos)
2201 : Expression(isolate), exception_(exception), pos_(pos) {}
2204 Expression* exception_;
2209 class FunctionLiteral: public Expression {
2315 : Expression(isolate),
2359 class SharedFunctionInfoLiteral: public Expression {
2371 : Expression(isolate),
2379 class ThisFunction: public Expression {
2384 explicit ThisFunction(Isolate* isolate): Expression(isolate) {}
2417 // expression.
2772 virtual void VisitExpressions(ZoneList<Expression*>* expressions);
2962 ExpressionStatement* NewExpressionStatement(Expression* expression) {
2963 ExpressionStatement* stmt = new(zone_) ExpressionStatement(expression);
2977 ReturnStatement* NewReturnStatement(Expression* expression) {
2978 ReturnStatement* stmt = new(zone_) ReturnStatement(expression);
2983 Expression* expression,
2986 scope, expression, statement);
2990 IfStatement* NewIfStatement(Expression* condition,
3066 ZoneList<Expression*>* values,
3089 Property* NewProperty(Expression* obj, Expression* key, int pos) {
3094 Call* NewCall(Expression* expression,
3095 ZoneList<Expression*>* arguments,
3097 Call* call = new(zone_) Call(isolate_, expression, arguments, pos);
3101 CallNew* NewCallNew(Expression* expression,
3102 ZoneList<Expression*>* arguments,
3104 CallNew* call = new(zone_) CallNew(isolate_, expression, arguments, pos);
3110 ZoneList<Expression*>* arguments) {
3117 Expression* expression,
3120 new(zone_) UnaryOperation(isolate_, op, expression, pos);
3125 Expression* left,
3126 Expression* right,
3135 Expression* expr,
3143 Expression* left,
3144 Expression* right,
3151 Conditional* NewConditional(Expression* condition,
3152 Expression* then_expression,
3153 Expression* else_expression,
3163 Expression* target,
3164 Expression* value,
3172 Yield* NewYield(Expression *generator_object,
3173 Expression* expression,
3177 isolate_, generator_object, expression, yield_kind, pos);
3181 Throw* NewThrow(Expression* exception, int pos) {
