[runtime] Support Proxy setPrototypeOf trap

src/ast/ast-value-factory.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 47 matching lines @@
 
  protected:
   // This is null until the string is internalized.
   Handle<String> string_;
 };
 
 
 class AstRawString : public AstString {
  public:
   int length() const override {
-    if (is_one_byte_)
-      return literal_bytes_.length();
+    if (is_one_byte_) return literal_bytes_.length();
     return literal_bytes_.length() / 2;
   }
 
   int byte_length() const { return literal_bytes_.length(); }
 
   void Internalize(Isolate* isolate) override;
 
   bool AsArrayIndex(uint32_t* index) const;
 
   // The string is not null-terminated, use length() to find out the length.
-  const unsigned char* raw_data() const {
-    return literal_bytes_.start();
-  }
+  const unsigned char* raw_data() const { return literal_bytes_.start(); }
   bool is_one_byte() const { return is_one_byte_; }
   bool IsOneByteEqualTo(const char* data) const;
   uint16_t FirstCharacter() const {
-    if (is_one_byte_)
-      return literal_bytes_[0];
+    if (is_one_byte_) return literal_bytes_[0];
     const uint16_t* c =
         reinterpret_cast<const uint16_t*>(literal_bytes_.start());
     return *c;
   }
 
   // For storing AstRawStrings in a hash map.
-  uint32_t hash() const {
-    return hash_;
-  }
+  uint32_t hash() const { return hash_; }
 
  private:
   friend class AstValueFactory;
   friend class AstRawStringInternalizationKey;
 
   AstRawString(bool is_one_byte, const Vector<const byte>& literal_bytes,
-            uint32_t hash)
+               uint32_t hash)
       : is_one_byte_(is_one_byte), literal_bytes_(literal_bytes), hash_(hash) {}
 
-  AstRawString()
-      : is_one_byte_(true),
-        hash_(0) {}
+  AstRawString() : is_one_byte_(true), hash_(0) {}
 
   bool is_one_byte_;
 
   // Points to memory owned by Zone.
   Vector<const byte> literal_bytes_;
   uint32_t hash_;
 };
 
 
 class AstConsString : public AstString {
  public:
   AstConsString(const AstString* left, const AstString* right)
-      : left_(left),
-        right_(right) {}
+      : left_(left), right_(right) {}
 
   int length() const override { return left_->length() + right_->length(); }
 
   void Internalize(Isolate* isolate) override;
 
  private:
   friend class AstValueFactory;
 
   const AstString* left_;
   const AstString* right_;
 };
 
 
 // AstValue is either a string, a number, a string array, a boolean, or a
 // special value (null, undefined, the hole).
 class AstValue : public ZoneObject {
  public:
-  bool IsString() const {
-    return type_ == STRING;
-  }
+  bool IsString() const { return type_ == STRING; }
 
   bool IsNumber() const {
     return type_ == NUMBER || type_ == NUMBER_WITH_DOT || type_ == SMI;
   }
 
   bool ContainsDot() const { return type_ == NUMBER_WITH_DOT; }
 
   const AstRawString* AsString() const {
-    if (type_ == STRING)
-      return string_;
+    if (type_ == STRING) return string_;
     UNREACHABLE();
     return 0;
   }
 
   double AsNumber() const {
-    if (type_ == NUMBER || type_ == NUMBER_WITH_DOT)
-      return number_;
-    if (type_ == SMI)
-      return smi_;
+    if (type_ == NUMBER || type_ == NUMBER_WITH_DOT) return number_;
+    if (type_ == SMI) return smi_;
     UNREACHABLE();
     return 0;
   }
 
   bool EqualsString(const AstRawString* string) const {
     return type_ == STRING && string_ == string;
   }
 
   bool IsPropertyName() const;
 
@@ skipping 133 matching lines @@
         reinterpret_cast<const uint8_t*>(string), StrLength(string)));
   }
   const AstRawString* GetTwoByteString(Vector<const uint16_t> literal) {
     return GetTwoByteStringInternal(literal);
   }
   const AstRawString* GetString(Handle<String> literal);
   const AstConsString* NewConsString(const AstString* left,
                                      const AstString* right);
 
   void Internalize(Isolate* isolate);
-  bool IsInternalized() {
-    return isolate_ != NULL;
-  }
+  bool IsInternalized() { return isolate_ != NULL; }
 
 #define F(name, str)                                                    \
   const AstRawString* name##_string() {                                 \
     if (name##_string_ == NULL) {                                       \
       const char* data = str;                                           \
       name##_string_ = GetOneByteString(                                \
           Vector<const uint8_t>(reinterpret_cast<const uint8_t*>(data), \
                                 static_cast<int>(strlen(data))));       \
     }                                                                   \
     return name##_string_;                                              \
@@ skipping 39 matching lines @@
   OTHER_CONSTANTS(F)
 #undef F
 };
 }  // namespace internal
 }  // namespace v8
 
 #undef STRING_CONSTANTS
 #undef OTHER_CONSTANTS
 
 #endif  // V8_AST_AST_VALUE_FACTORY_H_