Lines Matching refs:Expression
127 class Expression;
188 class Expression : public AstNode {
277 Expression(int pos, NodeType type) : AstNode(pos, type) {
285 class FailureExpression : public Expression {
289 FailureExpression() : Expression(kNoSourcePosition, kFailureExpression) {}
446 void Initialize(Expression* cond, Statement* body) {
451 Expression* cond() const { return cond_; }
460 Expression* cond_;
466 void Initialize(Expression* cond, Statement* body) {
471 Expression* cond() const { return cond_; }
480 Expression* cond_;
486 void Initialize(Statement* init, Expression* cond, Statement* next,
495 Expression* cond() const { return cond_; }
509 Expression* cond_;
527 void Initialize(Expression* each, Expression* subject, Statement* body) {
533 Expression* each() const { return each_; }
534 Expression* subject() const { return subject_; }
543 Expression* each_;
544 Expression* subject_;
572 void set_expression(Expression* e) { expression_ = e; }
573 Expression* expression() const { return expression_; }
579 ExpressionStatement(Expression* expression, int pos)
582 Expression* expression_;
625 Expression* expression() const { return expression_; }
644 ReturnStatement(Expression* expression, Type type, int pos, int end_position)
651 Expression* expression_;
661 Expression* expression() const { return expression_; }
669 WithStatement(Scope* scope, Expression* expression, Statement* statement,
677 Expression* expression_;
684 Expression* label() const {
694 CaseClause(Zone* zone, Expression* label,
697 Expression* label_;
704 Expression* tag() const { return tag_; }
705 void set_tag(Expression* t) { tag_ = t; }
713 SwitchStatement(Zone* zone, Expression* tag, int pos)
716 Expression* tag_;
731 Expression* condition() const { return condition_; }
742 IfStatement(Expression* condition, Statement* then_statement,
749 Expression* condition_;
922 class Literal final : public Expression {
1002 using TypeField = Expression::NextBitField<Type, 4>;
1004 Literal(int smi, int position) : Expression(position, kLiteral), smi_(smi) {
1009 : Expression(position, kLiteral), number_(number) {
1014 : Expression(position, kLiteral), bigint_(bigint) {
1019 : Expression(position, kLiteral), string_(string) {
1024 : Expression(position, kLiteral), boolean_(boolean) {
1028 Literal(Type type, int position) : Expression(position, kLiteral) {
1043 class MaterializedLiteral : public Expression {
1050 MaterializedLiteral(int pos, NodeType type) : Expression(pos, type) {}
1119 static Handle<Object> GetBoilerplateValue(Expression* expression,
1198 Expression* key() const { return key_and_is_computed_name_.GetPointer(); }
1199 Expression* value() const { return value_; }
1207 LiteralProperty(Expression* key, Expression* value, bool is_computed_name)
1210 base::PointerWithPayload<Expression, bool, 1> key_and_is_computed_name_;
1211 Expression* value_;
1245 ObjectLiteralProperty(Expression* key, Expression* value, Kind kind,
1247 ObjectLiteralProperty(AstValueFactory* ast_value_factory, Expression* key,
1248 Expression* value, bool is_computed_name);
1388 ArrayLiteralBoilerplateBuilder(const ZonePtrList<Expression>* values,
1422 const ZonePtrList<Expression>* values_;
1431 const ZonePtrList<Expression>* values() const { return &values_; }
1440 ArrayLiteral(Zone* zone, const ScopedPtrList<Expression>& values,
1446 ZonePtrList<Expression> values_;
1452 class ThisExpression final : public Expression {
1456 explicit ThisExpression(int pos) : Expression(pos, kThisExpression) {}
1459 class VariableProxy final : public Expression {
1553 : Expression(start_position, kVariableProxy),
1565 using IsAssignedField = Expression::NextBitField<bool, 1>;
1583 class OptionalChain final : public Expression {
1585 Expression* expression() const { return expression_; }
1591 explicit OptionalChain(Expression* expression)
1592 : Expression(0, kOptionalChain), expression_(expression) {}
1594 Expression* expression_;
1612 class Property final : public Expression {
1620 Expression* obj() const { return obj_; }
1621 Expression* key() const { return key_; }
1660 Property(Expression* obj, Expression* key, int pos, bool optional_chain)
1661 : Expression(pos, kProperty), obj_(obj), key_(key) {
1665 using IsOptionalChainLinkField = Expression::NextBitField<bool, 1>;
1667 Expression* obj_;
1668 Expression* key_;
1671 class CallBase : public Expression {
1673 Expression* expression() const { return expression_; }
1674 const ZonePtrList<Expression>* arguments() const { return &arguments_; }
1682 CallBase(Zone* zone, NodeType type, Expression* expression,
1683 const ScopedPtrList<Expression>& arguments, int pos, bool has_spread)
1684 : Expression(pos, type),
1698 using SpreadPositionField = Expression::NextBitField<SpreadPosition, 2>;
1703 Expression* expression_;
1704 ZonePtrList<Expression> arguments_;
1750 Call(Zone* zone, Expression* expression,
1751 const ScopedPtrList<Expression>& arguments, int pos, bool has_spread,
1760 Call(Zone* zone, Expression* expression,
1761 const ScopedPtrList<Expression>& arguments, int pos,
1779 CallNew(Zone* zone, Expression* expression,
1780 const ScopedPtrList<Expression>& arguments, int pos, bool has_spread)
1788 class CallRuntime final : public Expression {
1790 const ZonePtrList<Expression>* arguments() const { return &arguments_; }
1809 const ScopedPtrList<Expression>& arguments, int pos)
1810 : Expression(pos, kCallRuntime),
1814 const ScopedPtrList<Expression>& arguments, int pos)
1815 : Expression(pos, kCallRuntime),
1822 ZonePtrList<Expression> arguments_;
1826 class UnaryOperation final : public Expression {
1829 Expression* expression() const { return expression_; }
1835 UnaryOperation(Token::Value op, Expression* expression, int pos)
1836 : Expression(pos, kUnaryOperation), expression_(expression) {
1841 Expression* expression_;
1843 using OperatorField = Expression::NextBitField<Token::Value, 7>;
1847 class BinaryOperation final : public Expression {
1850 Expression* left() const { return left_; }
1851 Expression* right() const { return right_; }
1855 bool IsSmiLiteralOperation(Expression** subexpr, Smi* literal);
1861 BinaryOperation(Token::Value op, Expression* left, Expression* right, int pos)
1862 : Expression(pos, kBinaryOperation), left_(left), right_(right) {
1867 Expression* left_;
1868 Expression* right_;
1870 using OperatorField = Expression::NextBitField<Token::Value, 7>;
1873 class NaryOperation final : public Expression {
1876 Expression* first() const { return first_; }
1877 Expression* subsequent(size_t index) const {
1886 void AddSubsequent(Expression* expr, int pos) {
1894 NaryOperation(Zone* zone, Token::Value op, Expression* first,
1896 : Expression(first->position(), kNaryOperation),
1920 Expression* first_;
1923 Expression* expression;
1925 NaryOperationEntry(Expression* e, int pos)
1930 using OperatorField = Expression::NextBitField<Token::Value, 7>;
1933 class CountOperation final : public Expression {
1940 Expression* expression() const { return expression_; }
1946 CountOperation(Token::Value op, bool is_prefix, Expression* expr, int pos)
1947 : Expression(pos, kCountOperation), expression_(expr) {
1951 using IsPrefixField = Expression::NextBitField<bool, 1>;
1954 Expression* expression_;
1958 class CompareOperation final : public Expression {
1961 Expression* left() const { return left_; }
1962 Expression* right() const { return right_; }
1965 bool IsLiteralCompareTypeof(Expression** expr, Literal** literal);
1966 bool IsLiteralCompareUndefined(Expression** expr);
1967 bool IsLiteralCompareNull(Expression** expr);
1973 CompareOperation(Token::Value op, Expression* left, Expression* right,
1975 : Expression(pos, kCompareOperation), left_(left), right_(right) {
1980 Expression* left_;
1981 Expression* right_;
1983 using OperatorField = Expression::NextBitField<Token::Value, 7>;
1987 class Spread final : public Expression {
1989 Expression* expression() const { return expression_; }
1997 Spread(Expression* expression, int pos, int expr_pos)
1998 : Expression(pos, kSpread),
2003 Expression* expression_;
2006 class Conditional final : public Expression {
2008 Expression* condition() const { return condition_; }
2009 Expression* then_expression() const { return then_expression_; }
2010 Expression* else_expression() const { return else_expression_; }
2016 Conditional(Expression* condition, Expression* then_expression,
2017 Expression* else_expression, int position)
2018 : Expression(position, kConditional),
2023 Expression* condition_;
2024 Expression* then_expression_;
2025 Expression* else_expression_;
2028 class Assignment : public Expression {
2031 Expression* target() const { return target_; }
2032 Expression* value() const { return value_; }
2047 Assignment(NodeType type, Token::Value op, Expression* target,
2048 Expression* value, int pos);
2054 using TokenField = Expression::NextBitField<Token::Value, 7>;
2057 Expression* target_;
2058 Expression* value_;
2069 CompoundAssignment(Token::Value op, Expression* target, Expression* value,
2086 class Suspend : public Expression {
2095 Expression* expression() const { return expression_; }
2107 Suspend(NodeType node_type, Expression* expression, int pos,
2109 : Expression(pos, node_type), expression_(expression) {
2113 Expression* expression_;
2115 using OnAbruptResumeField = Expression::NextBitField<OnAbruptResume, 1>;
2122 Yield(Expression* expression, int pos, OnAbruptResume on_abrupt_resume)
2130 YieldStar(Expression* expression, int pos)
2140 Await(Expression* expression, int pos)
2144 class Throw final : public Expression {
2146 Expression* exception() const { return exception_; }
2152 Throw(Expression* exception, int pos)
2153 : Expression(pos, kThrow), exception_(exception) {}
2155 Expression* exception_;
2159 class FunctionLiteral final : public Expression {
2316 : Expression(position, kFunctionLiteral),
2339 Expression::NextBitField<FunctionSyntaxKind, 3>;
2403 ClassLiteralProperty(Expression* key, Expression* value, Kind kind,
2480 class ClassLiteral final : public Expression {
2486 Expression* extends() const { return extends_; }
2520 ClassLiteral(ClassScope* scope, Expression* extends,
2530 : Expression(start_position, kClassLiteral),
2549 Expression* extends_;
2555 using HasStaticComputedNames = Expression::NextBitField<bool, 1>;
2563 class NativeFunctionLiteral final : public Expression {
2575 : Expression(pos, kNativeFunctionLiteral),
2584 class SuperPropertyReference final : public Expression {
2593 : Expression(pos, kSuperPropertyReference), home_object_(home_object) {}
2599 class SuperCallReference final : public Expression {
2611 : Expression(pos, kSuperCallReference),
2624 class ImportCallExpression final : public Expression {
2626 Expression* specifier() const { return specifier_; }
2627 Expression* import_assertions() const { return import_assertions_; }
2633 ImportCallExpression(Expression* specifier, int pos)
2634 : Expression(pos, kImportCallExpression),
2638 ImportCallExpression(Expression* specifier, Expression* import_assertions,
2640 : Expression(pos, kImportCallExpression),
2644 Expression* specifier_;
2645 Expression* import_assertions_;
2650 class EmptyParentheses final : public Expression {
2655 explicit EmptyParentheses(int pos) : Expression(pos, kEmptyParentheses) {
2662 class GetTemplateObject final : public Expression {
2680 : Expression(pos, kGetTemplateObject),
2688 class TemplateLiteral final : public Expression {
2693 const ZonePtrList<Expression>* substitutions() const {
2701 const ZonePtrList<Expression>* substitutions, int pos)
2702 : Expression(pos, kTemplateLiteral),
2707 const ZonePtrList<Expression>* substitutions_;
2731 void VisitExpressions(const ZonePtrList<Expression>* expressions) {
2737 Expression* expression = expressions->at(i);
2857 SwitchStatement* NewSwitchStatement(Expression* tag, int pos) {
2878 ExpressionStatement* NewExpressionStatement(Expression* expression, int pos) {
2891 Expression* expression, int pos,
2897 ReturnStatement* NewAsyncReturnStatement(Expression* expression, int pos,
2904 Expression* expression, int pos,
2911 Expression* expression,
2917 IfStatement* NewIfStatement(Expression* condition, Statement* then_statement,
2992 CaseClause* NewCaseClause(Expression* label,
3037 Expression* key, Expression* value, ObjectLiteralProperty::Kind kind,
3043 ObjectLiteral::Property* NewObjectLiteralProperty(Expression* key,
3044 Expression* value,
3055 ArrayLiteral* NewArrayLiteral(const ScopedPtrList<Expression>& values,
3060 ArrayLiteral* NewArrayLiteral(const ScopedPtrList<Expression>& values,
3086 OptionalChain* NewOptionalChain(Expression* expression) {
3090 Property* NewProperty(Expression* obj, Expression* key, int pos,
3095 Call* NewCall(Expression* expression,
3096 const ScopedPtrList<Expression>& arguments, int pos,
3105 Call* NewTaggedTemplate(Expression* expression,
3106 const ScopedPtrList<Expression>& arguments, int pos) {
3111 CallNew* NewCallNew(Expression* expression,
3112 const ScopedPtrList<Expression>& arguments, int pos,
3118 const ScopedPtrList<Expression>& arguments,
3125 const ScopedPtrList<Expression>& arguments,
3131 const ScopedPtrList<Expression>& arguments,
3137 Expression* expression,
3143 Expression* left,
3144 Expression* right,
3149 NaryOperation* NewNaryOperation(Token::Value op, Expression* first,
3156 Expression* expr,
3162 Expression* left,
3163 Expression* right,
3168 Spread* NewSpread(Expression* expression, int pos, int expr_pos) {
3172 Conditional* NewConditional(Expression* condition,
3173 Expression* then_expression,
3174 Expression* else_expression,
3181 Expression* target,
3182 Expression* value,
3203 Suspend* NewYield(Expression* expression, int pos,
3209 YieldStar* NewYieldStar(Expression* expression, int pos) {
3213 Await* NewAwait(Expression* expression, int pos) {
3218 Throw* NewThrow(Expression* exception, int pos) {
3255 Expression* key, Expression* value, ClassLiteralProperty::Kind kind,
3272 ClassScope* scope, Expression* extends, FunctionLiteral* constructor,
3317 const ZonePtrList<Expression>* substitutions, int pos) {
3321 ImportCallExpression* NewImportCallExpression(Expression* specifier,
3326 ImportCallExpression* NewImportCallExpression(Expression* specifier,
3327 Expression* import_assertions,