Fix JSON.stringify wrt harmony proxies.

src/json-stringifier.h

 // Copyright 2012 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 30 matching lines @@
 
   MaybeObject* Stringify(Handle<Object> object);
 
  private:
   static const int kInitialPartLength = 32;
   static const int kMaxPartLength = 16 * 1024;
   static const int kPartLengthGrowthFactor = 2;
 
   enum Result { UNCHANGED, SUCCESS, EXCEPTION, CIRCULAR, STACK_OVERFLOW };
 
-  template <bool is_ascii> void Extend();
+  void Extend();
 
   void ChangeEncoding();
 
   void ShrinkCurrentPart();
 
   template <bool is_ascii, typename Char>
   INLINE(void Append_(Char c));
 
   template <bool is_ascii, typename Char>
   INLINE(void Append_(const Char* chars));
@@ skipping 13 matching lines @@
       Append_<false>(chars);
     }
   }
 
   Handle<Object> GetProperty(Handle<JSObject> object,
                              Handle<String> key);
 
   Handle<Object> ApplyToJsonFunction(Handle<Object> object,
                                      Handle<Object> key);
 
+  Result SerializeGeneric(Handle<Object> object,
+                          Handle<Object> key,
+                          bool deferred_comma,
+                          bool deferred_key);
+
   // Entry point to serialize the object.
   INLINE(Result SerializeObject(Handle<Object> obj)) {
-    return Serialize_<false>(obj, false, isolate_->factory()->empty_string());
+    return Serialize_<false>(obj, false, factory_->empty_string());
   }
 
   // Serialize an array element.
   // The index may serve as argument for the toJSON function.
   INLINE(Result SerializeElement(Handle<Object> object, int i)) {
     return Serialize_<false>(object, false, Handle<Object>(Smi::FromInt(i)));
   }
 
   // Serialize a object property.
   // The key may or may not be serialized depending on the property.
@@ skipping 42 matching lines @@
   template <typename Char>
   INLINE(bool DoNotEscape(Char c));
 
   template <typename Char>
   INLINE(Vector<const Char> GetCharVector(Handle<String> string));
 
   Result StackPush(Handle<Object> object);
   void StackPop();
 
   INLINE(Handle<String> accumulator()) {
-    return Handle<String>(String::cast(accumulator_store_->value()));
+    return Handle<String>(String::cast(accumulator_store_->value()), isolate_);
   }
 
   INLINE(void set_accumulator(Handle<String> string)) {
     return accumulator_store_->set_value(*string);
   }
 
   Isolate* isolate_;
+  Factory* factory_;
   // We use a value wrapper for the string accumulator to keep the
   // (indirect) handle to it in the outermost handle scope.
   Handle<JSValue> accumulator_store_;
   Handle<String> current_part_;
   Handle<String> tojson_symbol_;
   Handle<JSArray> stack_;
   int current_index_;
   int part_length_;
   bool is_ascii_;
 
@@ skipping 34 matching lines @@
     "h\0      i\0      j\0      k\0      "
     "l\0      m\0      n\0      o\0      "
     "p\0      q\0      r\0      s\0      "
     "t\0      u\0      v\0      w\0      "
     "x\0      y\0      z\0      {\0      "
     "|\0      }\0      ~\0      \177\0      ";
 
 
 BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate)
     : isolate_(isolate), current_index_(0), is_ascii_(true) {
+  factory_ = isolate_->factory();
   accumulator_store_ = Handle<JSValue>::cast(
-      isolate_->factory()->ToObject(isolate_->factory()->empty_string()));
+                           factory_->ToObject(factory_->empty_string()));
   part_length_ = kInitialPartLength;
-  current_part_ =
-      isolate_->factory()->NewRawAsciiString(kInitialPartLength);
-  tojson_symbol_ = isolate_->factory()->LookupAsciiSymbol("toJSON");
-  stack_ = isolate_->factory()->NewJSArray(8);
+  current_part_ = factory_->NewRawAsciiString(kInitialPartLength);
+  tojson_symbol_ = factory_->LookupAsciiSymbol("toJSON");
+  stack_ = factory_->NewJSArray(8);
 }
 
 
 MaybeObject* BasicJsonStringifier::Stringify(Handle<Object> object) {
   switch (SerializeObject(object)) {
     case UNCHANGED:
       return isolate_->heap()->undefined_value();
     case SUCCESS:
       ShrinkCurrentPart();
-      return *isolate_->factory()->NewConsString(accumulator(), current_part_);
+      return *factory_->NewConsString(accumulator(), current_part_);
     case CIRCULAR:
-      return isolate_->Throw(*isolate_->factory()->NewTypeError(
+      return isolate_->Throw(*factory_->NewTypeError(
                  "circular_structure", HandleVector<Object>(NULL, 0)));
     case STACK_OVERFLOW:
       return isolate_->StackOverflow();
     default:
       return Failure::Exception();
   }
 }
 
 
 template <bool is_ascii, typename Char>
 void BasicJsonStringifier::Append_(Char c) {
   if (is_ascii) {
     SeqAsciiString::cast(*current_part_)->SeqAsciiStringSet(
         current_index_++, c);
   } else {
     SeqTwoByteString::cast(*current_part_)->SeqTwoByteStringSet(
         current_index_++, c);
   }
-  if (current_index_ == part_length_) Extend<is_ascii>();
+  if (current_index_ == part_length_) Extend();
 }
 
 
 template <bool is_ascii, typename Char>
 void BasicJsonStringifier::Append_(const Char* chars) {
   for ( ; *chars != '\0'; chars++) Append_<is_ascii, Char>(*chars);
 }
 
 
 Handle<Object> BasicJsonStringifier::GetProperty(Handle<JSObject> object,
                                                  Handle<String> key) {
   LookupResult lookup(isolate_);
   object->LocalLookupRealNamedProperty(*key, &lookup);
-  if (!lookup.IsProperty()) return isolate_->factory()->undefined_value();
+  if (!lookup.IsProperty()) return factory_->undefined_value();
   switch (lookup.type()) {
     case NORMAL: {
       Object* value = lookup.holder()->GetNormalizedProperty(&lookup);
       ASSERT(!value->IsTheHole());
-      return Handle<Object>(value);
+      return Handle<Object>(value, isolate_);
     }
     case FIELD: {
       Object* value = lookup.holder()->FastPropertyAt(lookup.GetFieldIndex());
       ASSERT(!value->IsTheHole());
-      return Handle<Object>(value);
+      return Handle<Object>(value, isolate_);
     }
     case CONSTANT_FUNCTION:
-      return Handle<Object>(lookup.GetConstantFunction());
+      return Handle<Object>(lookup.GetConstantFunction(), isolate_);
     default: {
       PropertyAttributes attr;
       return Object::GetProperty(object, object, &lookup, key, &attr);
     }
   }
   return Handle<Object>::null();
 }
 
 
 Handle<Object> BasicJsonStringifier::ApplyToJsonFunction(
     Handle<Object> object, Handle<Object> key) {
   LookupResult lookup(isolate_);
   JSObject::cast(*object)->LookupRealNamedProperty(*tojson_symbol_, &lookup);
   if (!lookup.IsProperty()) return object;
   PropertyAttributes attr;
   Handle<Object> fun =
       Object::GetProperty(object, object, &lookup, tojson_symbol_, &attr);
   if (!fun->IsJSFunction()) return object;
 
   // Call toJSON function.
-  if (key->IsSmi()) key = isolate_->factory()->NumberToString(key);
+  if (key->IsSmi()) key = factory_->NumberToString(key);
   Handle<Object> argv[] = { key };
   bool has_exception = false;
   HandleScope scope(isolate_);
   object = Execution::Call(fun, object, 1, argv, &has_exception);
   // Return empty handle to signal an exception.
   if (has_exception) return Handle<Object>::null();
   return scope.CloseAndEscape(object);
 }
 
 
@@ skipping 23 matching lines @@
 
 
 template <bool deferred_string_key>
 BasicJsonStringifier::Result BasicJsonStringifier::Serialize_(
     Handle<Object> object, bool comma, Handle<Object> key) {
   if (object->IsJSObject()) {
     object = ApplyToJsonFunction(object, key);
     if (object.is_null()) return EXCEPTION;
   }
 
-  if (object->IsJSObject()) {
-    if (object->IsJSFunction()) return UNCHANGED;
+  if (object->IsSmi()) {
     if (deferred_string_key) SerializeDeferredKey(comma, key);
-    if (object->IsJSArray()) {
-      return SerializeJSArray(Handle<JSArray>::cast(object));
-    } else if (object->IsJSValue()) {
-      return SerializeJSValue(Handle<JSValue>::cast(object));
-    } else {
-      return SerializeJSObject(Handle<JSObject>::cast(object));
-    }
+    return SerializeSmi(Smi::cast(*object));
   }
 
-  // Handle non-JSObject.
-  if (object->IsString()) {
-    if (deferred_string_key) SerializeDeferredKey(comma, key);
-    SerializeString(Handle<String>::cast(object));
-    return SUCCESS;
-  } else if (object->IsSmi()) {
-    if (deferred_string_key) SerializeDeferredKey(comma, key);
-    return SerializeSmi(Smi::cast(*object));
-  } else if (object->IsHeapNumber()) {
-    if (deferred_string_key) SerializeDeferredKey(comma, key);
-    return SerializeHeapNumber(Handle<HeapNumber>::cast(object));
-  } else if (object->IsOddball()) {
-    switch (Oddball::cast(*object)->kind()) {
-      case Oddball::kFalse:
+  switch (HeapObject::cast(*object)->map()->instance_type()) {
+    case HEAP_NUMBER_TYPE:
+      if (deferred_string_key) SerializeDeferredKey(comma, key);
+      return SerializeHeapNumber(Handle<HeapNumber>::cast(object));
+    case ODDBALL_TYPE:
+      switch (Oddball::cast(*object)->kind()) {
+        case Oddball::kFalse:
+          if (deferred_string_key) SerializeDeferredKey(comma, key);
+          Append("false");
+          return SUCCESS;
+        case Oddball::kTrue:
+          if (deferred_string_key) SerializeDeferredKey(comma, key);
+          Append("true");
+          return SUCCESS;
+        case Oddball::kNull:
+          if (deferred_string_key) SerializeDeferredKey(comma, key);
+          Append("null");
+          return SUCCESS;
+        default:
+          return UNCHANGED;
+      }
+    case JS_ARRAY_TYPE:
+      if (deferred_string_key) SerializeDeferredKey(comma, key);
+      return SerializeJSArray(Handle<JSArray>::cast(object));
+    case JS_VALUE_TYPE:
+      if (deferred_string_key) SerializeDeferredKey(comma, key);
+      return SerializeJSValue(Handle<JSValue>::cast(object));
+    case JS_FUNCTION_TYPE:
+      return UNCHANGED;
+    default:
+      if (object->IsString()) {
         if (deferred_string_key) SerializeDeferredKey(comma, key);
-        Append("false");
+        SerializeString(Handle<String>::cast(object));
         return SUCCESS;
-      case Oddball::kTrue:
+      } else if (object->IsJSObject()) {
         if (deferred_string_key) SerializeDeferredKey(comma, key);
-        Append("true");
-        return SUCCESS;
-      case Oddball::kNull:
-        if (deferred_string_key) SerializeDeferredKey(comma, key);
-        Append("null");
-        return SUCCESS;
-    }
+        return SerializeJSObject(Handle<JSObject>::cast(object));
+      } else {
+        return SerializeGeneric(object, key, comma, deferred_string_key);
+      }
   }
-
-  return UNCHANGED;
 }
 
 
+BasicJsonStringifier::Result BasicJsonStringifier::SerializeGeneric(
+    Handle<Object> object,
+    Handle<Object> key,
+    bool deferred_comma,
+    bool deferred_key) {
+  Handle<JSObject> builtins(isolate_->native_context()->builtins());
+  Handle<JSFunction> builtin = Handle<JSFunction>::cast(
+      v8::internal::GetProperty(builtins, "JSONSerializeAdapter"));
+
+  Handle<Object> argv[] = { key, object };
+  bool has_exception = false;
+  Handle<Object> result =
+      Execution::Call(builtin, object, 2, argv, &has_exception);
+  if (has_exception) return EXCEPTION;
+  if (result->IsUndefined()) return UNCHANGED;
+  if (deferred_key) {
+    if (key->IsSmi()) key = factory_->NumberToString(key);
+    SerializeDeferredKey(deferred_comma, key);
+  }
+
+  Handle<String> result_string = Handle<String>::cast(result);
+  // Shrink current part, attach it to the accumulator, also attach the result
+  // string to the accumulator, and allocate a new part.
+  ShrinkCurrentPart();  // Shrink.
+  part_length_ = kInitialPartLength;  // Allocate conservatively.
+  Extend();             // Attach current part and allocate new part.
+  // Attach result string to the accumulator.
+  set_accumulator(factory_->NewConsString(accumulator(), result_string));
+  return SUCCESS;
+}
+
+
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSValue(
     Handle<JSValue> object) {
   bool has_exception = false;
   String* class_name = object->class_name();
   if (class_name == isolate_->heap()->String_symbol()) {
     Handle<Object> value = Execution::ToString(object, &has_exception);
     if (has_exception) return EXCEPTION;
     SerializeString(Handle<String>::cast(value));
   } else if (class_name == isolate_->heap()->Number_symbol()) {
     Handle<Object> value = Execution::ToNumber(object, &has_exception);
@@ skipping 35 matching lines @@
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArray(
     Handle<JSArray> object) {
   HandleScope handle_scope(isolate_);
   Result stack_push = StackPush(object);
   if (stack_push != SUCCESS) return stack_push;
   int length = Smi::cast(object->length())->value();
   Append('[');
   switch (object->GetElementsKind()) {
     case FAST_SMI_ELEMENTS: {
-      Handle<FixedArray> elements(FixedArray::cast(object->elements()));
+      Handle<FixedArray> elements(
+          FixedArray::cast(object->elements()), isolate_);
       for (int i = 0; i < length; i++) {
         if (i > 0) Append(',');
         SerializeSmi(Smi::cast(elements->get(i)));
       }
       break;
     }
     case FAST_DOUBLE_ELEMENTS: {
       Handle<FixedDoubleArray> elements(
-          FixedDoubleArray::cast(object->elements()));
+          FixedDoubleArray::cast(object->elements()), isolate_);
       for (int i = 0; i < length; i++) {
         if (i > 0) Append(',');
         SerializeDouble(elements->get_scalar(i));
       }
       break;
     }
     case FAST_ELEMENTS: {
-      Handle<FixedArray> elements(FixedArray::cast(object->elements()));
+      Handle<FixedArray> elements(
+          FixedArray::cast(object->elements()), isolate_);
       for (int i = 0; i < length; i++) {
         if (i > 0) Append(',');
-        Result result = SerializeElement(Handle<Object>(elements->get(i)), i);
+        Result result =
+            SerializeElement(Handle<Object>(elements->get(i), isolate_), i);
         if (result == SUCCESS) continue;
         if (result == UNCHANGED) {
           Append("null");
         } else {
           return result;
         }
       }
       break;
     }
     // TODO(yangguo):  The FAST_HOLEY_* cases could be handled in a faster way.
@@ skipping 32 matching lines @@
   return SUCCESS;
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSObject(
     Handle<JSObject> object) {
   HandleScope handle_scope(isolate_);
   Result stack_push = StackPush(object);
   if (stack_push != SUCCESS) return stack_push;
   if (object->IsJSGlobalProxy()) {
-    object = Handle<JSObject>(JSObject::cast(object->GetPrototype()));
+    object = Handle<JSObject>(
+                 JSObject::cast(object->GetPrototype()), isolate_);
     ASSERT(object->IsGlobalObject());
   }
   bool has_exception = false;
   Handle<FixedArray> contents =
       GetKeysInFixedArrayFor(object, LOCAL_ONLY, &has_exception);
   if (has_exception) return EXCEPTION;
   Append('{');
   bool comma = false;
   for (int i = 0; i < contents->length(); i++) {
     Object* key = contents->get(i);
     Handle<String> key_handle;
     Handle<Object> property;
     if (key->IsString()) {
-      key_handle = Handle<String>(String::cast(key));
+      key_handle = Handle<String>(String::cast(key), isolate_);
       property = GetProperty(object, key_handle);
     } else {
       ASSERT(key->IsNumber());
-      key_handle = isolate_->factory()->NumberToString(Handle<Object>(key));
+      key_handle = factory_->NumberToString(Handle<Object>(key, isolate_));
       uint32_t index;
       if (key->IsSmi()) {
         property = Object::GetElement(object, Smi::cast(key)->value());
       } else if (key_handle->AsArrayIndex(&index)) {
         property = Object::GetElement(object, index);
       } else {
         property = GetProperty(object, key_handle);
       }
     }
     if (property.is_null()) return EXCEPTION;
     Result result = SerializeProperty(property, comma, key_handle);
     if (!comma && result == SUCCESS) comma = true;
     if (result >= EXCEPTION) return result;
   }
   Append('}');
   StackPop();
   current_part_ = handle_scope.CloseAndEscape(current_part_);
   return SUCCESS;
 }
 
 
 void BasicJsonStringifier::ShrinkCurrentPart() {
   ASSERT(current_index_ < part_length_);
   if (current_index_ == 0) {
-    current_part_ = isolate_->factory()->empty_string();
+    current_part_ = factory_->empty_string();
     return;
   }
 
   int string_size, allocated_string_size;
   if (is_ascii_) {
     allocated_string_size = SeqAsciiString::SizeFor(part_length_);
     string_size = SeqAsciiString::SizeFor(current_index_);
   } else {
     allocated_string_size = SeqTwoByteString::SizeFor(part_length_);
     string_size = SeqTwoByteString::SizeFor(current_index_);
   }
 
   int delta = allocated_string_size - string_size;
   current_part_->set_length(current_index_);
 
   // String sizes are pointer size aligned, so that we can use filler objects
   // that are a multiple of pointer size.
   Address end_of_string = current_part_->address() + string_size;
   isolate_->heap()->CreateFillerObjectAt(end_of_string, delta);
   if (Marking::IsBlack(Marking::MarkBitFrom(*current_part_))) {
     MemoryChunk::IncrementLiveBytesFromMutator(
         current_part_->address(), -delta);
   }
 }
 
 
-template <bool is_ascii>
 void BasicJsonStringifier::Extend() {
-  set_accumulator(
-      isolate_->factory()->NewConsString(accumulator(), current_part_));
+  set_accumulator(factory_->NewConsString(accumulator(), current_part_));
   if (part_length_ <= kMaxPartLength / kPartLengthGrowthFactor) {
     part_length_ *= kPartLengthGrowthFactor;
   }
-  if (is_ascii) {
-    current_part_ =
-        isolate_->factory()->NewRawAsciiString(part_length_);
+  if (is_ascii_) {
+    current_part_ = factory_->NewRawAsciiString(part_length_);
   } else {
-    current_part_ =
-        isolate_->factory()->NewRawTwoByteString(part_length_);
+    current_part_ = factory_->NewRawTwoByteString(part_length_);
   }
   current_index_ = 0;
 }
 
 
 void BasicJsonStringifier::ChangeEncoding() {
   ShrinkCurrentPart();
-  set_accumulator(
-      isolate_->factory()->NewConsString(accumulator(), current_part_));
-  current_part_ =
-      isolate_->factory()->NewRawTwoByteString(part_length_);
+  set_accumulator(factory_->NewConsString(accumulator(), current_part_));
+  current_part_ = factory_->NewRawTwoByteString(part_length_);
   current_index_ = 0;
   is_ascii_ = false;
 }
 
 
 template <typename SrcChar, typename DestChar>
 void BasicJsonStringifier::SerializeStringUnchecked_(const SrcChar* src,
                                                      DestChar* dest,
                                                      int length) {
   dest += current_index_;
@@ skipping 105 matching lines @@
       SerializeString_<false, char>(flat.ToAsciiVector(), object);
     } else {
       SerializeString_<false, uc16>(flat.ToUC16Vector(), object);
     }
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSON_STRINGIFIER_H_