[runtime] Support Proxy setPrototypeOf trap

src/ast/ast.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/ast/ast.h"
 
 #include <cmath>  // For isfinite.
 #include "src/ast/scopes.h"
 #include "src/builtins.h"
 #include "src/code-stubs.h"
 #include "src/contexts.h"
 #include "src/conversions.h"
 #include "src/hashmap.h"
 #include "src/parsing/parser.h"
 #include "src/property.h"
 #include "src/property-details.h"
 #include "src/string-stream.h"
 #include "src/type-info.h"
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // All the Accept member functions for each syntax tree node type.
 
-#define DECL_ACCEPT(type)                                       \
+#define DECL_ACCEPT(type) \
   void type::Accept(AstVisitor* v) { v->Visit##type(this); }
 AST_NODE_LIST(DECL_ACCEPT)
 #undef DECL_ACCEPT
 
 
 // ----------------------------------------------------------------------------
 // Implementation of other node functionality.
 
 
 bool Expression::IsSmiLiteral() const {
@@ skipping 124 matching lines @@
 
 void CountOperation::AssignFeedbackVectorSlots(Isolate* isolate,
                                                FeedbackVectorSpec* spec,
                                                FeedbackVectorSlotCache* cache) {
   AssignVectorSlots(expression(), spec, &slot_);
 }
 
 
 Token::Value Assignment::binary_op() const {
   switch (op()) {
-    case Token::ASSIGN_BIT_OR: return Token::BIT_OR;
-    case Token::ASSIGN_BIT_XOR: return Token::BIT_XOR;
-    case Token::ASSIGN_BIT_AND: return Token::BIT_AND;
-    case Token::ASSIGN_SHL: return Token::SHL;
-    case Token::ASSIGN_SAR: return Token::SAR;
-    case Token::ASSIGN_SHR: return Token::SHR;
-    case Token::ASSIGN_ADD: return Token::ADD;
-    case Token::ASSIGN_SUB: return Token::SUB;
-    case Token::ASSIGN_MUL: return Token::MUL;
-    case Token::ASSIGN_DIV: return Token::DIV;
-    case Token::ASSIGN_MOD: return Token::MOD;
-    default: UNREACHABLE();
+    case Token::ASSIGN_BIT_OR:
+      return Token::BIT_OR;
+    case Token::ASSIGN_BIT_XOR:
+      return Token::BIT_XOR;
+    case Token::ASSIGN_BIT_AND:
+      return Token::BIT_AND;
+    case Token::ASSIGN_SHL:
+      return Token::SHL;
+    case Token::ASSIGN_SAR:
+      return Token::SAR;
+    case Token::ASSIGN_SHR:
+      return Token::SHR;
+    case Token::ASSIGN_ADD:
+      return Token::ADD;
+    case Token::ASSIGN_SUB:
+      return Token::SUB;
+    case Token::ASSIGN_MUL:
+      return Token::MUL;
+    case Token::ASSIGN_DIV:
+      return Token::DIV;
+    case Token::ASSIGN_MOD:
+      return Token::MOD;
+    default:
+      UNREACHABLE();
   }
   return Token::ILLEGAL;
 }
 
 
 bool FunctionLiteral::AllowsLazyCompilation() {
   return scope()->AllowsLazyCompilation();
 }
 
 
 bool FunctionLiteral::AllowsLazyCompilationWithoutContext() {
   return scope()->AllowsLazyCompilationWithoutContext();
 }
 
 
 int FunctionLiteral::start_position() const {
   return scope()->start_position();
 }
 
 
-int FunctionLiteral::end_position() const {
-  return scope()->end_position();
-}
+int FunctionLiteral::end_position() const { return scope()->end_position(); }
 
 
 LanguageMode FunctionLiteral::language_mode() const {
   return scope()->language_mode();
 }
 
 
 bool FunctionLiteral::NeedsHomeObject(Expression* expr) {
   if (expr == nullptr || !expr->IsFunctionLiteral()) return false;
   DCHECK_NOT_NULL(expr->AsFunctionLiteral()->scope());
@@ skipping 48 matching lines @@
     ObjectLiteral::Property* property = properties()->at(i);
     Expression* value = property->value();
     if (FunctionLiteral::NeedsHomeObject(value)) {
       property->SetSlot(spec->AddStoreICSlot());
     }
   }
 }
 
 
 bool ObjectLiteral::Property::IsCompileTimeValue() {
-  return kind_ == CONSTANT ||
-      (kind_ == MATERIALIZED_LITERAL &&
-       CompileTimeValue::IsCompileTimeValue(value_));
+  return kind_ == CONSTANT || (kind_ == MATERIALIZED_LITERAL &&
+                               CompileTimeValue::IsCompileTimeValue(value_));
 }
 
 
 void ObjectLiteral::Property::set_emit_store(bool emit_store) {
   emit_store_ = emit_store;
 }
 
 
-bool ObjectLiteral::Property::emit_store() {
-  return emit_store_;
-}
+bool ObjectLiteral::Property::emit_store() { return emit_store_; }
 
 
 void ObjectLiteral::AssignFeedbackVectorSlots(Isolate* isolate,
                                               FeedbackVectorSpec* spec,
                                               FeedbackVectorSlotCache* cache) {
   // This logic that computes the number of slots needed for vector store
   // ics must mirror FullCodeGenerator::VisitObjectLiteral.
   int property_index = 0;
   for (; property_index < properties()->length(); property_index++) {
     ObjectLiteral::Property* property = properties()->at(property_index);
@@ skipping 86 matching lines @@
 bool ObjectLiteral::IsBoilerplateProperty(ObjectLiteral::Property* property) {
   return property != NULL &&
          property->kind() != ObjectLiteral::Property::PROTOTYPE;
 }
 
 
 void ObjectLiteral::BuildConstantProperties(Isolate* isolate) {
   if (!constant_properties_.is_null()) return;
 
   // Allocate a fixed array to hold all the constant properties.
-  Handle<FixedArray> constant_properties = isolate->factory()->NewFixedArray(
-      boilerplate_properties_ * 2, TENURED);
+  Handle<FixedArray> constant_properties =
+      isolate->factory()->NewFixedArray(boilerplate_properties_ * 2, TENURED);
 
   int position = 0;
   // Accumulate the value in local variables and store it at the end.
   bool is_simple = true;
   int depth_acc = 1;
   uint32_t max_element_index = 0;
   uint32_t elements = 0;
   for (int i = 0; i < properties()->length(); i++) {
     ObjectLiteral::Property* property = properties()->at(i);
     if (!IsBoilerplateProperty(property)) {
@@ skipping 30 matching lines @@
       may_store_doubles_ = true;
     }
 
     is_simple = is_simple && !value->IsUninitialized();
 
     // Keep track of the number of elements in the object literal and
     // the largest element index.  If the largest element index is
     // much larger than the number of elements, creating an object
     // literal with fast elements will be a waste of space.
     uint32_t element_index = 0;
-    if (key->IsString()
-        && Handle<String>::cast(key)->AsArrayIndex(&element_index)
-        && element_index > max_element_index) {
+    if (key->IsString() &&
+        Handle<String>::cast(key)->AsArrayIndex(&element_index) &&
+        element_index > max_element_index) {
       max_element_index = element_index;
       elements++;
     } else if (key->IsSmi()) {
       int key_value = Smi::cast(*key)->value();
-      if (key_value > 0
-          && static_cast<uint32_t>(key_value) > max_element_index) {
+      if (key_value > 0 &&
+          static_cast<uint32_t>(key_value) > max_element_index) {
         max_element_index = key_value;
       }
       elements++;
     }
 
     // Add name, value pair to the fixed array.
     constant_properties->set(position++, *key);
     constant_properties->set(position++, *value);
   }
 
@@ skipping 139 matching lines @@
 }
 
 
 static bool IsTypeof(Expression* expr) {
   UnaryOperation* maybe_unary = expr->AsUnaryOperation();
   return maybe_unary != NULL && maybe_unary->op() == Token::TYPEOF;
 }
 
 
 // Check for the pattern: typeof <expression> equals <string literal>.
-static bool MatchLiteralCompareTypeof(Expression* left,
-                                      Token::Value op,
-                                      Expression* right,
-                                      Expression** expr,
+static bool MatchLiteralCompareTypeof(Expression* left, Token::Value op,
+                                      Expression* right, Expression** expr,
                                       Handle<String>* check) {
   if (IsTypeof(left) && right->IsStringLiteral() && Token::IsEqualityOp(op)) {
     *expr = left->AsUnaryOperation()->expression();
     *check = Handle<String>::cast(right->AsLiteral()->value());
     return true;
   }
   return false;
 }
 
 
 bool CompareOperation::IsLiteralCompareTypeof(Expression** expr,
                                               Handle<String>* check) {
   return MatchLiteralCompareTypeof(left_, op_, right_, expr, check) ||
-      MatchLiteralCompareTypeof(right_, op_, left_, expr, check);
+         MatchLiteralCompareTypeof(right_, op_, left_, expr, check);
 }
 
 
 static bool IsVoidOfLiteral(Expression* expr) {
   UnaryOperation* maybe_unary = expr->AsUnaryOperation();
-  return maybe_unary != NULL &&
-      maybe_unary->op() == Token::VOID &&
-      maybe_unary->expression()->IsLiteral();
+  return maybe_unary != NULL && maybe_unary->op() == Token::VOID &&
+         maybe_unary->expression()->IsLiteral();
 }
 
 
 // Check for the pattern: void <literal> equals <expression> or
 // undefined equals <expression>
-static bool MatchLiteralCompareUndefined(Expression* left,
-                                         Token::Value op,
-                                         Expression* right,
-                                         Expression** expr,
+static bool MatchLiteralCompareUndefined(Expression* left, Token::Value op,
+                                         Expression* right, Expression** expr,
                                          Isolate* isolate) {
   if (IsVoidOfLiteral(left) && Token::IsEqualityOp(op)) {
     *expr = right;
     return true;
   }
   if (left->IsUndefinedLiteral(isolate) && Token::IsEqualityOp(op)) {
     *expr = right;
     return true;
   }
   return false;
 }
 
 
-bool CompareOperation::IsLiteralCompareUndefined(
-    Expression** expr, Isolate* isolate) {
+bool CompareOperation::IsLiteralCompareUndefined(Expression** expr,
+                                                 Isolate* isolate) {
   return MatchLiteralCompareUndefined(left_, op_, right_, expr, isolate) ||
-      MatchLiteralCompareUndefined(right_, op_, left_, expr, isolate);
+         MatchLiteralCompareUndefined(right_, op_, left_, expr, isolate);
 }
 
 
 // Check for the pattern: null equals <expression>
-static bool MatchLiteralCompareNull(Expression* left,
-                                    Token::Value op,
-                                    Expression* right,
-                                    Expression** expr) {
+static bool MatchLiteralCompareNull(Expression* left, Token::Value op,
+                                    Expression* right, Expression** expr) {
   if (left->IsNullLiteral() && Token::IsEqualityOp(op)) {
     *expr = right;
     return true;
   }
   return false;
 }
 
 
 bool CompareOperation::IsLiteralCompareNull(Expression** expr) {
   return MatchLiteralCompareNull(left_, op_, right_, expr) ||
-      MatchLiteralCompareNull(right_, op_, left_, expr);
+         MatchLiteralCompareNull(right_, op_, left_, expr);
 }
 
 
 // ----------------------------------------------------------------------------
 // Inlining support
 
 bool Declaration::IsInlineable() const {
   return proxy()->var()->IsStackAllocated();
 }
 
-bool FunctionDeclaration::IsInlineable() const {
-  return false;
-}
+bool FunctionDeclaration::IsInlineable() const { return false; }
 
 
 // ----------------------------------------------------------------------------
 // Recording of type feedback
 
 // TODO(rossberg): all RecordTypeFeedback functions should disappear
 // once we use the common type field in the AST consistently.
 
 void Expression::RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle) {
   set_to_boolean_types(oracle->ToBooleanTypes(test_id()));
@@ skipping 82 matching lines @@
     // changes
     Expression* expression = expressions->at(i);
     if (expression != NULL) Visit(expression);
   }
 }
 
 
 // ----------------------------------------------------------------------------
 // Regular expressions
 
-#define MAKE_ACCEPT(Name)                                            \
-  void* RegExp##Name::Accept(RegExpVisitor* visitor, void* data) {   \
-    return visitor->Visit##Name(this, data);                         \
+#define MAKE_ACCEPT(Name)                                          \
+  void* RegExp##Name::Accept(RegExpVisitor* visitor, void* data) { \
+    return visitor->Visit##Name(this, data);                       \
   }
 FOR_EACH_REG_EXP_TREE_TYPE(MAKE_ACCEPT)
 #undef MAKE_ACCEPT
 
-#define MAKE_TYPE_CASE(Name)                                         \
-  RegExp##Name* RegExpTree::As##Name() {                             \
-    return NULL;                                                     \
-  }                                                                  \
+#define MAKE_TYPE_CASE(Name)                            \
+  RegExp##Name* RegExpTree::As##Name() { return NULL; } \
   bool RegExpTree::Is##Name() { return false; }
 FOR_EACH_REG_EXP_TREE_TYPE(MAKE_TYPE_CASE)
 #undef MAKE_TYPE_CASE
 
-#define MAKE_TYPE_CASE(Name)                                        \
-  RegExp##Name* RegExp##Name::As##Name() {                          \
-    return this;                                                    \
-  }                                                                 \
+#define MAKE_TYPE_CASE(Name)                              \
+  RegExp##Name* RegExp##Name::As##Name() { return this; } \
   bool RegExp##Name::Is##Name() { return true; }
 FOR_EACH_REG_EXP_TREE_TYPE(MAKE_TYPE_CASE)
 #undef MAKE_TYPE_CASE
 
 
 static Interval ListCaptureRegisters(ZoneList<RegExpTree*>* children) {
   Interval result = Interval::Empty();
   for (int i = 0; i < children->length(); i++)
     result = result.Union(children->at(i)->CaptureRegisters());
   return result;
@@ skipping 33 matching lines @@
 
 bool RegExpAssertion::IsAnchoredAtEnd() {
   return assertion_type() == RegExpAssertion::END_OF_INPUT;
 }
 
 
 bool RegExpAlternative::IsAnchoredAtStart() {
   ZoneList<RegExpTree*>* nodes = this->nodes();
   for (int i = 0; i < nodes->length(); i++) {
     RegExpTree* node = nodes->at(i);
-    if (node->IsAnchoredAtStart()) { return true; }
-    if (node->max_match() > 0) { return false; }
+    if (node->IsAnchoredAtStart()) {
+      return true;
+    }
+    if (node->max_match() > 0) {
+      return false;
+    }
   }
   return false;
 }
 
 
 bool RegExpAlternative::IsAnchoredAtEnd() {
   ZoneList<RegExpTree*>* nodes = this->nodes();
   for (int i = nodes->length() - 1; i >= 0; i--) {
     RegExpTree* node = nodes->at(i);
-    if (node->IsAnchoredAtEnd()) { return true; }
-    if (node->max_match() > 0) { return false; }
+    if (node->IsAnchoredAtEnd()) {
+      return true;
+    }
+    if (node->max_match() > 0) {
+      return false;
+    }
   }
   return false;
 }
 
 
 bool RegExpDisjunction::IsAnchoredAtStart() {
   ZoneList<RegExpTree*>* alternatives = this->alternatives();
   for (int i = 0; i < alternatives->length(); i++) {
-    if (!alternatives->at(i)->IsAnchoredAtStart())
-      return false;
+    if (!alternatives->at(i)->IsAnchoredAtStart()) return false;
   }
   return true;
 }
 
 
 bool RegExpDisjunction::IsAnchoredAtEnd() {
   ZoneList<RegExpTree*>* alternatives = this->alternatives();
   for (int i = 0; i < alternatives->length(); i++) {
-    if (!alternatives->at(i)->IsAnchoredAtEnd())
-      return false;
+    if (!alternatives->at(i)->IsAnchoredAtEnd()) return false;
   }
   return true;
 }
 
 
 bool RegExpLookaround::IsAnchoredAtStart() {
   return is_positive() && type() == LOOKAHEAD && body()->IsAnchoredAtStart();
 }
 
 
-bool RegExpCapture::IsAnchoredAtStart() {
-  return body()->IsAnchoredAtStart();
-}
+bool RegExpCapture::IsAnchoredAtStart() { return body()->IsAnchoredAtStart(); }
 
 
-bool RegExpCapture::IsAnchoredAtEnd() {
-  return body()->IsAnchoredAtEnd();
-}
+bool RegExpCapture::IsAnchoredAtEnd() { return body()->IsAnchoredAtEnd(); }
 
 
 // Convert regular expression trees to a simple sexp representation.
 // This representation should be different from the input grammar
 // in as many cases as possible, to make it more difficult for incorrect
 // parses to look as correct ones which is likely if the input and
 // output formats are alike.
 class RegExpUnparser final : public RegExpVisitor {
  public:
   RegExpUnparser(std::ostream& os, Zone* zone) : os_(os), zone_(zone) {}
   void VisitCharacterRange(CharacterRange that);
 #define MAKE_CASE(Name) void* Visit##Name(RegExp##Name*, void* data) override;
   FOR_EACH_REG_EXP_TREE_TYPE(MAKE_CASE)
 #undef MAKE_CASE
  private:
   std::ostream& os_;
   Zone* zone_;
 };
 
 
 void* RegExpUnparser::VisitDisjunction(RegExpDisjunction* that, void* data) {
   os_ << "(|";
-  for (int i = 0; i <  that->alternatives()->length(); i++) {
+  for (int i = 0; i < that->alternatives()->length(); i++) {
     os_ << " ";
     that->alternatives()->at(i)->Accept(this, data);
   }
   os_ << ")";
   return NULL;
 }
 
 
 void* RegExpUnparser::VisitAlternative(RegExpAlternative* that, void* data) {
   os_ << "(:";
-  for (int i = 0; i <  that->nodes()->length(); i++) {
+  for (int i = 0; i < that->nodes()->length(); i++) {
     os_ << " ";
     that->nodes()->at(i)->Accept(this, data);
   }
   os_ << ")";
   return NULL;
 }
 
 
 void RegExpUnparser::VisitCharacterRange(CharacterRange that) {
   os_ << AsUC16(that.from());
   if (!that.IsSingleton()) {
     os_ << "-" << AsUC16(that.to());
   }
 }
 
 
-
 void* RegExpUnparser::VisitCharacterClass(RegExpCharacterClass* that,
                                           void* data) {
   if (that->is_negated()) os_ << "^";
   os_ << "[";
   for (int i = 0; i < that->ranges(zone_)->length(); i++) {
     if (i > 0) os_ << " ";
     VisitCharacterRange(that->ranges(zone_)->at(i));
   }
   os_ << "]";
   return NULL;
 }
 
 
 void* RegExpUnparser::VisitAssertion(RegExpAssertion* that, void* data) {
   switch (that->assertion_type()) {
     case RegExpAssertion::START_OF_INPUT:
       os_ << "@^i";
       break;
     case RegExpAssertion::END_OF_INPUT:
       os_ << "@$i";
       break;
     case RegExpAssertion::START_OF_LINE:
       os_ << "@^l";
       break;
     case RegExpAssertion::END_OF_LINE:
       os_ << "@$l";
-       break;
+      break;
     case RegExpAssertion::BOUNDARY:
       os_ << "@b";
       break;
     case RegExpAssertion::NON_BOUNDARY:
       os_ << "@B";
       break;
   }
   return NULL;
 }
 
@@ skipping 132 matching lines @@
 bool Literal::Match(void* literal1, void* literal2) {
   const AstValue* x = static_cast<Literal*>(literal1)->raw_value();
   const AstValue* y = static_cast<Literal*>(literal2)->raw_value();
   return (x->IsString() && y->IsString() && x->AsString() == y->AsString()) ||
          (x->IsNumber() && y->IsNumber() && x->AsNumber() == y->AsNumber());
 }
 
 
 }  // namespace internal
 }  // namespace v8