Lines Matching defs:Expression
128 class Expression;
224 virtual Expression* AsExpression() { return NULL; }
296 class Expression: public AstNode {
315 virtual Expression* AsExpression() { return this; }
332 // True iff the expression is a literal represented as a smi.
335 // True iff the expression is a string literal.
338 // True iff the expression is the null literal.
361 explicit Expression(Isolate* isolate)
715 void Initialize(Expression* cond, Statement* body) {
720 Expression* cond() const { return cond_; }
722 // Position where condition expression starts. We need it to make
744 Expression* cond_;
755 void Initialize(Expression* cond, Statement* body) {
760 Expression* cond() const { return cond_; }
784 Expression* cond_;
796 Expression* cond,
806 Expression* cond() const { return cond_; }
841 Expression* cond_;
855 void Initialize(Expression* each, Expression* enumerable, Statement* body) {
861 Expression* each() const { return each_; }
862 Expression* enumerable() const { return enumerable_; }
881 Expression* each_;
882 Expression* enumerable_;
892 void set_expression(Expression* e) { expression_ = e; }
893 Expression* expression() const { return expression_; }
898 explicit ExpressionStatement(Expression* expression)
899 : expression_(expression) { }
902 Expression* expression_;
944 Expression* expression() const { return expression_; }
949 explicit ReturnStatement(Expression* expression)
950 : expression_(expression) { }
953 Expression* expression_;
961 Expression* expression() const { return expression_; }
967 WithStatement(Expression* expression, Statement* statement)
968 : expression_(expression),
972 Expression* expression_;
980 Expression* label,
985 Expression* label() const {
1006 Expression* label_;
1027 void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
1032 Expression* tag() const { return tag_; }
1044 Expression* tag_;
1061 Expression* condition() const { return condition_; }
1073 Expression* condition,
1085 Expression* condition_;
1210 class Literal: public Expression {
1260 : Expression(isolate),
1271 class MaterializedLiteral: public Expression {
1288 : Expression(isolate),
1317 Property(Literal* key, Expression* value, Isolate* isolate);
1320 Expression* value() { return value_; }
1341 Expression* value_;
1371 Expression* getter;
1372 Expression* setter;
1431 ZoneList<Expression*>* values() const { return values_; }
1441 ZoneList<Expression*>* values,
1452 ZoneList<Expression*>* values_;
1457 class VariableProxy: public Expression {
1511 class Property: public Expression {
1517 Expression* obj() const { return obj_; }
1518 Expression* key() const { return key_; }
1536 Expression* obj,
1537 Expression* key,
1539 : Expression(isolate),
1551 Expression* obj_;
1552 Expression* key_;
1565 class Call: public Expression {
1569 Expression* expression() const { return expression_; }
1570 ZoneList<Expression*>* arguments() const { return arguments_; }
1597 Expression* expression,
1598 ZoneList<Expression*>* arguments,
1600 : Expression(isolate),
1601 expression_(expression),
1609 Expression* expression_;
1610 ZoneList<Expression*>* arguments_;
1624 class CallNew: public Expression {
1628 Expression* expression() const { return expression_; }
1629 ZoneList<Expression*>* arguments() const { return arguments_; }
1643 Expression* expression,
1644 ZoneList<Expression*>* arguments,
1646 : Expression(isolate),
1647 expression_(expression),
1654 Expression* expression_;
1655 ZoneList<Expression*>* arguments_;
1669 class CallRuntime: public Expression {
1675 ZoneList<Expression*>* arguments() const { return arguments_; }
1684 ZoneList<Expression*>* arguments)
1685 : Expression(isolate),
1693 ZoneList<Expression*>* arguments_;
1697 class UnaryOperation: public Expression {
1704 Expression* expression() const { return expression_; }
1715 Expression* expression,
1717 : Expression(isolate),
1719 expression_(expression),
1732 Expression* expression_;
1742 class BinaryOperation: public Expression {
1749 Expression* left() const { return left_; }
1750 Expression* right() const { return right_; }
1761 Expression* left,
1762 Expression* right,
1764 : Expression(isolate), op_(op), left_(left), right_(right), pos_(pos) {
1773 Expression* left_;
1774 Expression* right_;
1782 class CountOperation: public Expression {
1794 Expression* expression() const { return expression_; }
1813 Expression
1815 : Expression(isolate),
1827 Expression* expression_;
1835 class CompareOperation: public Expression {
1840 Expression* left() const { return left_; }
1841 Expression* right() const { return right_; }
1850 bool IsLiteralCompareTypeof(Expression** expr, Handle<String>* check);
1851 bool IsLiteralCompareUndefined(Expression** expr);
1852 bool IsLiteralCompareNull(Expression** expr);
1859 Expression* left,
1860 Expression* right,
1862 : Expression(isolate),
1873 Expression* left_;
1874 Expression* right_;
1882 class Conditional: public Expression {
1886 Expression* condition() const { return condition_; }
1887 Expression* then_expression() const { return then_expression_; }
1888 Expression* else_expression() const { return else_expression_; }
1900 Expression* condition,
1901 Expression* then_expression,
1902 Expression* else_expression,
1905 : Expression(isolate),
1915 Expression* condition_;
1916 Expression* then_expression_;
1917 Expression* else_expression_;
1925 class Assignment: public Expression {
1934 Expression* target() const { return target_; }
1935 Expression* value() const { return value_; }
1965 Expression* target,
1966 Expression* value,
1981 Expression* target_;
1982 Expression* value_;
1996 class Throw: public Expression {
2000 Expression* exception() const { return exception_; }
2006 Throw(Isolate* isolate, Expression* exception, int pos)
2007 : Expression(isolate), exception_(exception), pos_(pos) {}
2010 Expression* exception_;
2015 class FunctionLiteral: public Expression {
2102 : Expression(isolate),
2147 class SharedFunctionInfoLiteral: public Expression {
2161 : Expression(isolate),
2169 class ThisFunction: public Expression {
2176 explicit ThisFunction(Isolate* isolate): Expression(isolate) {}
2209 // expression.
2564 virtual void VisitExpressions(ZoneList<Expression*>* expressions);
2723 ExpressionStatement* NewExpressionStatement(Expression* expression) {
2724 ExpressionStatement* stmt = new(zone_) ExpressionStatement(expression);
2738 ReturnStatement* NewReturnStatement(Expression* expression) {
2739 ReturnStatement* stmt = new(zone_) ReturnStatement(expression);
2743 WithStatement* NewWithStatement(Expression* expression,
2745 WithStatement* stmt = new(zone_) WithStatement(expression, statement);
2749 IfStatement* NewIfStatement(Expression* condition,
2824 ZoneList<Expression*>* values,
2848 Property* NewProperty(Expression* obj, Expression* key, int pos) {
2853 Call* NewCall(Expression* expression,
2854 ZoneList<Expression*>* arguments,
2856 Call* call = new(zone_) Call(isolate_, expression, arguments, pos);
2860 CallNew* NewCallNew(Expression* expression,
2861 ZoneList<Expression*>* arguments,
2863 CallNew* call = new(zone_) CallNew(isolate_, expression, arguments, pos);
2869 ZoneList<Expression*>* arguments) {
2876 Expression* expression,
2879 new(zone_) UnaryOperation(isolate_, op, expression, pos);
2884 Expression* left,
2885 Expression* right,
2894 Expression* expr,
2902 Expression* left,
2903 Expression* right,
2910 Conditional* NewConditional(Expression* condition,
2911 Expression* then_expression,
2912 Expression* else_expression,
2922 Expression* target,
2923 Expression* value,
2931 Throw* NewThrow(Expression* exception, int pos) {
