Merge V8 5.2.361.47 DO NOT MERGE
https://chromium.googlesource.com/v8/v8/+/5.2.361.47
FPIIM-449
Change-Id: Ibec421b85a9b88cb3a432ada642e469fe7e78346
(cherry picked from commit bcf72ee8e3b26f1d0726869c7ddb3921c68b09a8)
diff --git a/src/ast/ast.h b/src/ast/ast.h
index 52bac8e..bee0bab 100644
--- a/src/ast/ast.h
+++ b/src/ast/ast.h
@@ -337,10 +337,6 @@
// True iff the expression is a valid target for an assignment.
bool IsValidReferenceExpressionOrThis() const;
- // Expression type bounds
- Bounds bounds() const { return bounds_; }
- void set_bounds(Bounds bounds) { bounds_ = bounds; }
-
// Type feedback information for assignments and properties.
virtual bool IsMonomorphic() {
UNREACHABLE();
@@ -374,7 +370,6 @@
Expression(Zone* zone, int pos)
: AstNode(pos),
base_id_(BailoutId::None().ToInt()),
- bounds_(Bounds::Unbounded()),
bit_field_(0) {}
static int parent_num_ids() { return 0; }
void set_to_boolean_types(uint16_t types) {
@@ -390,7 +385,6 @@
int local_id(int n) const { return base_id() + parent_num_ids() + n; }
int base_id_;
- Bounds bounds_;
class ToBooleanTypesField : public BitField16<uint16_t, 0, 9> {};
uint16_t bit_field_;
// Ends with 16-bit field; deriving classes in turn begin with
@@ -598,7 +592,7 @@
ImportDeclaration(Zone* zone, VariableProxy* proxy,
const AstRawString* import_name,
const AstRawString* module_specifier, Scope* scope, int pos)
- : Declaration(zone, proxy, IMPORT, scope, pos),
+ : Declaration(zone, proxy, CONST, scope, pos),
import_name_(import_name),
module_specifier_(module_specifier) {}
@@ -647,6 +641,13 @@
Statement* body() const { return body_; }
void set_body(Statement* s) { body_ = s; }
+ int yield_count() const { return yield_count_; }
+ int first_yield_id() const { return first_yield_id_; }
+ void set_yield_count(int yield_count) { yield_count_ = yield_count; }
+ void set_first_yield_id(int first_yield_id) {
+ first_yield_id_ = first_yield_id;
+ }
+
static int num_ids() { return parent_num_ids() + 1; }
BailoutId OsrEntryId() const { return BailoutId(local_id(0)); }
virtual BailoutId ContinueId() const = 0;
@@ -658,7 +659,9 @@
protected:
IterationStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
: BreakableStatement(zone, labels, TARGET_FOR_ANONYMOUS, pos),
- body_(NULL) {}
+ body_(NULL),
+ yield_count_(0),
+ first_yield_id_(0) {}
static int parent_num_ids() { return BreakableStatement::num_ids(); }
void Initialize(Statement* body) { body_ = body; }
@@ -667,6 +670,8 @@
Statement* body_;
Label continue_target_;
+ int yield_count_;
+ int first_yield_id_;
};
@@ -779,17 +784,7 @@
ITERATE // for (each of subject) body;
};
- void Initialize(Expression* each, Expression* subject, Statement* body) {
- IterationStatement::Initialize(body);
- each_ = each;
- subject_ = subject;
- }
-
- Expression* each() const { return each_; }
- Expression* subject() const { return subject_; }
-
- void set_each(Expression* e) { each_ = e; }
- void set_subject(Expression* e) { subject_ = e; }
+ using IterationStatement::Initialize;
static const char* VisitModeString(VisitMode mode) {
return mode == ITERATE ? "for-of" : "for-in";
@@ -797,11 +792,7 @@
protected:
ForEachStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
- : IterationStatement(zone, labels, pos), each_(NULL), subject_(NULL) {}
-
- private:
- Expression* each_;
- Expression* subject_;
+ : IterationStatement(zone, labels, pos) {}
};
@@ -809,10 +800,22 @@
public:
DECLARE_NODE_TYPE(ForInStatement)
+ void Initialize(Expression* each, Expression* subject, Statement* body) {
+ ForEachStatement::Initialize(body);
+ each_ = each;
+ subject_ = subject;
+ }
+
Expression* enumerable() const {
return subject();
}
+ Expression* each() const { return each_; }
+ Expression* subject() const { return subject_; }
+
+ void set_each(Expression* e) { each_ = e; }
+ void set_subject(Expression* e) { subject_ = e; }
+
// Type feedback information.
void AssignFeedbackVectorSlots(Isolate* isolate, FeedbackVectorSpec* spec,
FeedbackVectorSlotCache* cache) override;
@@ -838,12 +841,17 @@
protected:
ForInStatement(Zone* zone, ZoneList<const AstRawString*>* labels, int pos)
- : ForEachStatement(zone, labels, pos), for_in_type_(SLOW_FOR_IN) {}
+ : ForEachStatement(zone, labels, pos),
+ each_(nullptr),
+ subject_(nullptr),
+ for_in_type_(SLOW_FOR_IN) {}
static int parent_num_ids() { return ForEachStatement::num_ids(); }
private:
int local_id(int n) const { return base_id() + parent_num_ids() + n; }
+ Expression* each_;
+ Expression* subject_;
ForInType for_in_type_;
FeedbackVectorSlot each_slot_;
FeedbackVectorSlot for_in_feedback_slot_;
@@ -854,15 +862,10 @@
public:
DECLARE_NODE_TYPE(ForOfStatement)
- void Initialize(Expression* each,
- Expression* subject,
- Statement* body,
- Variable* iterator,
- Expression* assign_iterator,
- Expression* next_result,
- Expression* result_done,
- Expression* assign_each) {
- ForEachStatement::Initialize(each, subject, body);
+ void Initialize(Statement* body, Variable* iterator,
+ Expression* assign_iterator, Expression* next_result,
+ Expression* result_done, Expression* assign_each) {
+ ForEachStatement::Initialize(body);
iterator_ = iterator;
assign_iterator_ = assign_iterator;
next_result_ = next_result;
@@ -870,10 +873,6 @@
assign_each_ = assign_each;
}
- Expression* iterable() const {
- return subject();
- }
-
Variable* iterator() const {
return iterator_;
}
@@ -2526,20 +2525,24 @@
Expression* generator_object() const { return generator_object_; }
Expression* expression() const { return expression_; }
+ int yield_id() const { return yield_id_; }
void set_generator_object(Expression* e) { generator_object_ = e; }
void set_expression(Expression* e) { expression_ = e; }
+ void set_yield_id(int yield_id) { yield_id_ = yield_id; }
protected:
Yield(Zone* zone, Expression* generator_object, Expression* expression,
int pos)
: Expression(zone, pos),
generator_object_(generator_object),
- expression_(expression) {}
+ expression_(expression),
+ yield_id_(-1) {}
private:
Expression* generator_object_;
Expression* expression_;
+ int yield_id_;
};
@@ -2584,12 +2587,12 @@
int start_position() const;
int end_position() const;
int SourceSize() const { return end_position() - start_position(); }
- bool is_declaration() const { return IsDeclaration::decode(bitfield_); }
+ bool is_declaration() const { return function_type() == kDeclaration; }
bool is_named_expression() const {
- return IsNamedExpression::decode(bitfield_);
+ return function_type() == kNamedExpression;
}
bool is_anonymous_expression() const {
- return IsAnonymousExpression::decode(bitfield_);
+ return function_type() == kAnonymousExpression;
}
LanguageMode language_mode() const;
@@ -2666,6 +2669,9 @@
bitfield_ = ShouldBeUsedOnceHint::update(bitfield_, true);
}
+ FunctionType function_type() const {
+ return FunctionTypeBits::decode(bitfield_);
+ }
FunctionKind kind() const { return FunctionKindBits::decode(bitfield_); }
int ast_node_count() { return ast_properties_.node_count(); }
@@ -2686,6 +2692,9 @@
return is_anonymous_expression();
}
+ int yield_count() { return yield_count_; }
+ void set_yield_count(int yield_count) { yield_count_ = yield_count; }
+
protected:
FunctionLiteral(Zone* zone, const AstString* name,
AstValueFactory* ast_value_factory, Scope* scope,
@@ -2705,12 +2714,10 @@
materialized_literal_count_(materialized_literal_count),
expected_property_count_(expected_property_count),
parameter_count_(parameter_count),
- function_token_position_(RelocInfo::kNoPosition) {
+ function_token_position_(RelocInfo::kNoPosition),
+ yield_count_(0) {
bitfield_ =
- IsDeclaration::encode(function_type == kDeclaration) |
- IsNamedExpression::encode(function_type == kNamedExpression) |
- IsAnonymousExpression::encode(function_type == kAnonymousExpression) |
- Pretenure::encode(false) |
+ FunctionTypeBits::encode(function_type) | Pretenure::encode(false) |
HasDuplicateParameters::encode(has_duplicate_parameters ==
kHasDuplicateParameters) |
IsFunction::encode(is_function) |
@@ -2720,15 +2727,13 @@
}
private:
- class IsDeclaration : public BitField16<bool, 0, 1> {};
- class IsNamedExpression : public BitField16<bool, 1, 1> {};
- class IsAnonymousExpression : public BitField16<bool, 2, 1> {};
- class Pretenure : public BitField16<bool, 3, 1> {};
- class HasDuplicateParameters : public BitField16<bool, 4, 1> {};
- class IsFunction : public BitField16<bool, 5, 1> {};
- class ShouldEagerCompile : public BitField16<bool, 6, 1> {};
- class ShouldBeUsedOnceHint : public BitField16<bool, 7, 1> {};
- class FunctionKindBits : public BitField16<FunctionKind, 8, 8> {};
+ class FunctionTypeBits : public BitField16<FunctionType, 0, 2> {};
+ class Pretenure : public BitField16<bool, 2, 1> {};
+ class HasDuplicateParameters : public BitField16<bool, 3, 1> {};
+ class IsFunction : public BitField16<bool, 4, 1> {};
+ class ShouldEagerCompile : public BitField16<bool, 5, 1> {};
+ class ShouldBeUsedOnceHint : public BitField16<bool, 6, 1> {};
+ class FunctionKindBits : public BitField16<FunctionKind, 7, 9> {};
// Start with 16-bit field, which should get packed together
// with Expression's trailing 16-bit field.
@@ -2746,6 +2751,7 @@
int expected_property_count_;
int parameter_count_;
int function_token_position_;
+ int yield_count_;
};
@@ -3041,6 +3047,30 @@
// ----------------------------------------------------------------------------
+// Traversing visitor
+// - fully traverses the entire AST.
+
+class AstTraversalVisitor : public AstVisitor {
+ public:
+ explicit AstTraversalVisitor(Isolate* isolate);
+ virtual ~AstTraversalVisitor() {}
+
+ // Iteration left-to-right.
+ void VisitDeclarations(ZoneList<Declaration*>* declarations) override;
+ void VisitStatements(ZoneList<Statement*>* statements) override;
+ void VisitExpressions(ZoneList<Expression*>* expressions) override;
+
+// Individual nodes
+#define DECLARE_VISIT(type) void Visit##type(type* node) override;
+ AST_NODE_LIST(DECLARE_VISIT)
+#undef DECLARE_VISIT
+
+ private:
+ DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
+ DISALLOW_COPY_AND_ASSIGN(AstTraversalVisitor);
+};
+
+// ----------------------------------------------------------------------------
// AstNode factory
class AstNodeFactory final BASE_EMBEDDED {