[json] move json parser and stringifier into own compilation units.

src/json-stringifier.h

 // 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.
 
 #ifndef V8_JSON_STRINGIFIER_H_
 #define V8_JSON_STRINGIFIER_H_
 
-#include "src/conversions.h"
-#include "src/lookup.h"
-#include "src/messages.h"
+#include "src/objects.h"
 #include "src/string-builder.h"
-#include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 class BasicJsonStringifier BASE_EMBEDDED {
  public:
   BasicJsonStringifier(Isolate* isolate, Handle<String> gap);
 
   ~BasicJsonStringifier() { DeleteArray(gap_); }
 
   MUST_USE_RESULT MaybeHandle<Object> Stringify(Handle<Object> object);
 
-  MUST_USE_RESULT INLINE(static MaybeHandle<Object> StringifyString(
-      Isolate* isolate,
-      Handle<String> object));
+  MUST_USE_RESULT static MaybeHandle<Object> StringifyString(
+      Isolate* isolate, Handle<String> object);
 
  private:
   enum Result { UNCHANGED, SUCCESS, EXCEPTION };
 
   MUST_USE_RESULT MaybeHandle<Object> ApplyToJsonFunction(
       Handle<Object> object,
       Handle<Object> key);
 
   // Entry point to serialize the object.
   INLINE(Result SerializeObject(Handle<Object> obj)) {
@@ skipping 16 matching lines @@
   INLINE(Result SerializeProperty(Handle<Object> object,
                                   bool deferred_comma,
                                   Handle<String> deferred_key)) {
     DCHECK(!deferred_key.is_null());
     return Serialize_<true>(object, deferred_comma, deferred_key);
   }
 
   template <bool deferred_string_key>
   Result Serialize_(Handle<Object> object, bool comma, Handle<Object> key);
 
-  void SerializeDeferredKey(bool deferred_comma, Handle<Object> deferred_key) {
-    Separator(!deferred_comma);
-    SerializeString(Handle<String>::cast(deferred_key));
-    builder_.AppendCharacter(':');
-    if (gap_ != nullptr) builder_.AppendCharacter(' ');
-  }
+  INLINE(void SerializeDeferredKey(bool deferred_comma,
+                                   Handle<Object> deferred_key));
 
   Result SerializeSmi(Smi* object);
 
   Result SerializeDouble(double number);
   INLINE(Result SerializeHeapNumber(Handle<HeapNumber> object)) {
     return SerializeDouble(object->value());
   }
 
   Result SerializeJSValue(Handle<JSValue> object);
 
@@ skipping 14 matching lines @@
 
   template <typename SrcChar, typename DestChar>
   INLINE(void SerializeString_(Handle<String> string));
 
   template <typename Char>
   INLINE(static bool DoNotEscape(Char c));
 
   INLINE(void NewLine());
   INLINE(void Indent() { indent_++; });
   INLINE(void Unindent() { indent_--; });
-  INLINE(void Separator(bool first) {
-    if (!first) builder_.AppendCharacter(',');
-    NewLine();
-  })
+  INLINE(void Separator(bool first));
 
   Result StackPush(Handle<Object> object);
   void StackPop();
 
   Factory* factory() { return isolate_->factory(); }
 
   Isolate* isolate_;
   IncrementalStringBuilder builder_;
   Handle<String> tojson_string_;
   Handle<JSArray> stack_;
   Handle<String> gap_string_;
   uc16* gap_;
   int indent_;
 
   static const int kJsonEscapeTableEntrySize = 8;
   static const char* const JsonEscapeTable;
 };
 
-
-// Translation table to escape Latin1 characters.
-// Table entries start at a multiple of 8 and are null-terminated.
-const char* const BasicJsonStringifier::JsonEscapeTable =
-    "\\u0000\0 \\u0001\0 \\u0002\0 \\u0003\0 "
-    "\\u0004\0 \\u0005\0 \\u0006\0 \\u0007\0 "
-    "\\b\0     \\t\0     \\n\0     \\u000b\0 "
-    "\\f\0     \\r\0     \\u000e\0 \\u000f\0 "
-    "\\u0010\0 \\u0011\0 \\u0012\0 \\u0013\0 "
-    "\\u0014\0 \\u0015\0 \\u0016\0 \\u0017\0 "
-    "\\u0018\0 \\u0019\0 \\u001a\0 \\u001b\0 "
-    "\\u001c\0 \\u001d\0 \\u001e\0 \\u001f\0 "
-    " \0      !\0      \\\"\0     #\0      "
-    "$\0      %\0      &\0      '\0      "
-    "(\0      )\0      *\0      +\0      "
-    ",\0      -\0      .\0      /\0      "
-    "0\0      1\0      2\0      3\0      "
-    "4\0      5\0      6\0      7\0      "
-    "8\0      9\0      :\0      ;\0      "
-    "<\0      =\0      >\0      ?\0      "
-    "@\0      A\0      B\0      C\0      "
-    "D\0      E\0      F\0      G\0      "
-    "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      _\0      "
-    "`\0      a\0      b\0      c\0      "
-    "d\0      e\0      f\0      g\0      "
-    "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      "
-    "\200\0      \201\0      \202\0      \203\0      "
-    "\204\0      \205\0      \206\0      \207\0      "
-    "\210\0      \211\0      \212\0      \213\0      "
-    "\214\0      \215\0      \216\0      \217\0      "
-    "\220\0      \221\0      \222\0      \223\0      "
-    "\224\0      \225\0      \226\0      \227\0      "
-    "\230\0      \231\0      \232\0      \233\0      "
-    "\234\0      \235\0      \236\0      \237\0      "
-    "\240\0      \241\0      \242\0      \243\0      "
-    "\244\0      \245\0      \246\0      \247\0      "
-    "\250\0      \251\0      \252\0      \253\0      "
-    "\254\0      \255\0      \256\0      \257\0      "
-    "\260\0      \261\0      \262\0      \263\0      "
-    "\264\0      \265\0      \266\0      \267\0      "
-    "\270\0      \271\0      \272\0      \273\0      "
-    "\274\0      \275\0      \276\0      \277\0      "
-    "\300\0      \301\0      \302\0      \303\0      "
-    "\304\0      \305\0      \306\0      \307\0      "
-    "\310\0      \311\0      \312\0      \313\0      "
-    "\314\0      \315\0      \316\0      \317\0      "
-    "\320\0      \321\0      \322\0      \323\0      "
-    "\324\0      \325\0      \326\0      \327\0      "
-    "\330\0      \331\0      \332\0      \333\0      "
-    "\334\0      \335\0      \336\0      \337\0      "
-    "\340\0      \341\0      \342\0      \343\0      "
-    "\344\0      \345\0      \346\0      \347\0      "
-    "\350\0      \351\0      \352\0      \353\0      "
-    "\354\0      \355\0      \356\0      \357\0      "
-    "\360\0      \361\0      \362\0      \363\0      "
-    "\364\0      \365\0      \366\0      \367\0      "
-    "\370\0      \371\0      \372\0      \373\0      "
-    "\374\0      \375\0      \376\0      \377\0      ";
-
-BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate, Handle<String> gap)
-    : isolate_(isolate), builder_(isolate), gap_string_(gap), indent_(0) {
-  tojson_string_ = factory()->toJSON_string();
-  stack_ = factory()->NewJSArray(8);
-  int gap_length = gap->length();
-  if (gap_length != 0) {
-    gap = String::Flatten(gap);
-    if (gap->IsTwoByteRepresentation()) builder_.ChangeEncoding();
-    DisallowHeapAllocation no_gc;
-    String::FlatContent flat = gap->GetFlatContent();
-    gap_ = NewArray<uc16>(gap_length + 1);
-    if (flat.IsOneByte()) {
-      CopyChars(gap_, flat.ToOneByteVector().start(), gap_length);
-    } else {
-      CopyChars(gap_, flat.ToUC16Vector().start(), gap_length);
-    }
-    gap_[gap_length] = '\0';
-  } else {
-    gap_ = nullptr;
-  }
-}
-
-
-MaybeHandle<Object> BasicJsonStringifier::Stringify(Handle<Object> object) {
-  Result result = SerializeObject(object);
-  if (result == UNCHANGED) return factory()->undefined_value();
-  if (result == SUCCESS) return builder_.Finish();
-  DCHECK(result == EXCEPTION);
-  return MaybeHandle<Object>();
-}
-
-
-MaybeHandle<Object> BasicJsonStringifier::StringifyString(
-    Isolate* isolate,  Handle<String> object) {
-  static const int kJsonQuoteWorstCaseBlowup = 6;
-  static const int kSpaceForQuotes = 2;
-  int worst_case_length =
-      object->length() * kJsonQuoteWorstCaseBlowup + kSpaceForQuotes;
-
-  if (worst_case_length > 32 * KB) {  // Slow path if too large.
-    BasicJsonStringifier stringifier(isolate,
-                                     isolate->factory()->empty_string());
-    return stringifier.Stringify(object);
-  }
-
-  object = String::Flatten(object);
-  DCHECK(object->IsFlat());
-  Handle<SeqString> result;
-  if (object->IsOneByteRepresentationUnderneath()) {
-    result = isolate->factory()
-                 ->NewRawOneByteString(worst_case_length)
-                 .ToHandleChecked();
-    IncrementalStringBuilder::NoExtendString<uint8_t> no_extend(
-        result, worst_case_length);
-    no_extend.Append('\"');
-    SerializeStringUnchecked_(object->GetFlatContent().ToOneByteVector(),
-                              &no_extend);
-    no_extend.Append('\"');
-    return no_extend.Finalize();
-  } else {
-    result = isolate->factory()
-                 ->NewRawTwoByteString(worst_case_length)
-                 .ToHandleChecked();
-    IncrementalStringBuilder::NoExtendString<uc16> no_extend(result,
-                                                             worst_case_length);
-    no_extend.Append('\"');
-    SerializeStringUnchecked_(object->GetFlatContent().ToUC16Vector(),
-                              &no_extend);
-    no_extend.Append('\"');
-    return no_extend.Finalize();
-  }
-}
-
-
-MaybeHandle<Object> BasicJsonStringifier::ApplyToJsonFunction(
-    Handle<Object> object, Handle<Object> key) {
-  LookupIterator it(object, tojson_string_,
-                    LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
-  Handle<Object> fun;
-  ASSIGN_RETURN_ON_EXCEPTION(isolate_, fun, Object::GetProperty(&it), Object);
-  if (!fun->IsCallable()) return object;
-
-  // Call toJSON function.
-  if (key->IsSmi()) key = factory()->NumberToString(key);
-  Handle<Object> argv[] = { key };
-  HandleScope scope(isolate_);
-  ASSIGN_RETURN_ON_EXCEPTION(
-      isolate_, object,
-      Execution::Call(isolate_, fun, object, 1, argv),
-      Object);
-  return scope.CloseAndEscape(object);
-}
-
-
-BasicJsonStringifier::Result BasicJsonStringifier::StackPush(
-    Handle<Object> object) {
-  StackLimitCheck check(isolate_);
-  if (check.HasOverflowed()) {
-    isolate_->StackOverflow();
-    return EXCEPTION;
-  }
-
-  int length = Smi::cast(stack_->length())->value();
-  {
-    DisallowHeapAllocation no_allocation;
-    FixedArray* elements = FixedArray::cast(stack_->elements());
-    for (int i = 0; i < length; i++) {
-      if (elements->get(i) == *object) {
-        AllowHeapAllocation allow_to_return_error;
-        Handle<Object> error =
-            factory()->NewTypeError(MessageTemplate::kCircularStructure);
-        isolate_->Throw(*error);
-        return EXCEPTION;
-      }
-    }
-  }
-  JSArray::SetLength(stack_, length + 1);
-  FixedArray::cast(stack_->elements())->set(length, *object);
-  return SUCCESS;
-}
-
-
-void BasicJsonStringifier::StackPop() {
-  int length = Smi::cast(stack_->length())->value();
-  stack_->set_length(Smi::FromInt(length - 1));
-}
-
-
-template <bool deferred_string_key>
-BasicJsonStringifier::Result BasicJsonStringifier::Serialize_(
-    Handle<Object> object, bool comma, Handle<Object> key) {
-  if (object->IsJSReceiver()) {
-    ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-        isolate_, object,
-        ApplyToJsonFunction(object, key),
-        EXCEPTION);
-  }
-
-  if (object->IsSmi()) {
-    if (deferred_string_key) SerializeDeferredKey(comma, key);
-    return SerializeSmi(Smi::cast(*object));
-  }
-
-  switch (HeapObject::cast(*object)->map()->instance_type()) {
-    case HEAP_NUMBER_TYPE:
-    case MUTABLE_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);
-          builder_.AppendCString("false");
-          return SUCCESS;
-        case Oddball::kTrue:
-          if (deferred_string_key) SerializeDeferredKey(comma, key);
-          builder_.AppendCString("true");
-          return SUCCESS;
-        case Oddball::kNull:
-          if (deferred_string_key) SerializeDeferredKey(comma, key);
-          builder_.AppendCString("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 SIMD128_VALUE_TYPE:
-    case SYMBOL_TYPE:
-      return UNCHANGED;
-    default:
-      if (object->IsString()) {
-        if (deferred_string_key) SerializeDeferredKey(comma, key);
-        SerializeString(Handle<String>::cast(object));
-        return SUCCESS;
-      } else {
-        DCHECK(object->IsJSReceiver());
-        if (object->IsCallable()) return UNCHANGED;
-        // Go to slow path for global proxy and objects requiring access checks.
-        if (deferred_string_key) SerializeDeferredKey(comma, key);
-        if (object->IsJSProxy()) {
-          return SerializeJSProxy(Handle<JSProxy>::cast(object));
-        }
-        return SerializeJSObject(Handle<JSObject>::cast(object));
-      }
-  }
-
-  UNREACHABLE();
-  return UNCHANGED;
-}
-
-
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSValue(
-    Handle<JSValue> object) {
-  String* class_name = object->class_name();
-  if (class_name == isolate_->heap()->String_string()) {
-    Handle<Object> value;
-    ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-        isolate_, value, Object::ToString(isolate_, object), EXCEPTION);
-    SerializeString(Handle<String>::cast(value));
-  } else if (class_name == isolate_->heap()->Number_string()) {
-    Handle<Object> value;
-    ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, value, Object::ToNumber(object),
-                                     EXCEPTION);
-    if (value->IsSmi()) return SerializeSmi(Smi::cast(*value));
-    SerializeHeapNumber(Handle<HeapNumber>::cast(value));
-  } else if (class_name == isolate_->heap()->Boolean_string()) {
-    Object* value = JSValue::cast(*object)->value();
-    DCHECK(value->IsBoolean());
-    builder_.AppendCString(value->IsTrue() ? "true" : "false");
-  } else {
-    // ES6 24.3.2.1 step 10.c, serialize as an ordinary JSObject.
-    return SerializeJSObject(object);
-  }
-  return SUCCESS;
-}
-
-
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeSmi(Smi* object) {
-  static const int kBufferSize = 100;
-  char chars[kBufferSize];
-  Vector<char> buffer(chars, kBufferSize);
-  builder_.AppendCString(IntToCString(object->value(), buffer));
-  return SUCCESS;
-}
-
-
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeDouble(
-    double number) {
-  if (std::isinf(number) || std::isnan(number)) {
-    builder_.AppendCString("null");
-    return SUCCESS;
-  }
-  static const int kBufferSize = 100;
-  char chars[kBufferSize];
-  Vector<char> buffer(chars, kBufferSize);
-  builder_.AppendCString(DoubleToCString(number, buffer));
-  return SUCCESS;
-}
-
-
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArray(
-    Handle<JSArray> object) {
-  HandleScope handle_scope(isolate_);
-  Result stack_push = StackPush(object);
-  if (stack_push != SUCCESS) return stack_push;
-  uint32_t length = 0;
-  CHECK(object->length()->ToArrayLength(&length));
-  DCHECK(!object->IsAccessCheckNeeded());
-  builder_.AppendCharacter('[');
-  Indent();
-  switch (object->GetElementsKind()) {
-    case FAST_SMI_ELEMENTS: {
-      Handle<FixedArray> elements(FixedArray::cast(object->elements()),
-                                  isolate_);
-      for (uint32_t i = 0; i < length; i++) {
-        Separator(i == 0);
-        SerializeSmi(Smi::cast(elements->get(i)));
-      }
-      break;
-    }
-    case FAST_DOUBLE_ELEMENTS: {
-      // Empty array is FixedArray but not FixedDoubleArray.
-      if (length == 0) break;
-      Handle<FixedDoubleArray> elements(
-          FixedDoubleArray::cast(object->elements()), isolate_);
-      for (uint32_t i = 0; i < length; i++) {
-        Separator(i == 0);
-        SerializeDouble(elements->get_scalar(i));
-      }
-      break;
-    }
-    case FAST_ELEMENTS: {
-      Handle<Object> old_length(object->length(), isolate_);
-      for (uint32_t i = 0; i < length; i++) {
-        if (object->length() != *old_length ||
-            object->GetElementsKind() != FAST_ELEMENTS) {
-          Result result = SerializeArrayLikeSlow(object, i, length);
-          if (result != SUCCESS) return result;
-          break;
-        }
-        Separator(i == 0);
-        Result result = SerializeElement(
-            isolate_,
-            Handle<Object>(FixedArray::cast(object->elements())->get(i),
-                           isolate_),
-            i);
-        if (result == SUCCESS) continue;
-        if (result == UNCHANGED) {
-          builder_.AppendCString("null");
-        } else {
-          return result;
-        }
-      }
-      break;
-    }
-    // The FAST_HOLEY_* cases could be handled in a faster way. They resemble
-    // the non-holey cases except that a lookup is necessary for holes.
-    default: {
-      Result result = SerializeArrayLikeSlow(object, 0, length);
-      if (result != SUCCESS) return result;
-      break;
-    }
-  }
-  Unindent();
-  if (length > 0) NewLine();
-  builder_.AppendCharacter(']');
-  StackPop();
-  return SUCCESS;
-}
-
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeArrayLikeSlow(
-    Handle<JSReceiver> object, uint32_t start, uint32_t length) {
-  for (uint32_t i = start; i < length; i++) {
-    Separator(i == 0);
-    Handle<Object> element;
-    ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-        isolate_, element, JSReceiver::GetElement(isolate_, object, i),
-        EXCEPTION);
-    if (element->IsUndefined()) {
-      builder_.AppendCString("null");
-    } else {
-      Result result = SerializeElement(isolate_, element, i);
-      if (result == SUCCESS) continue;
-      if (result == UNCHANGED) {
-        builder_.AppendCString("null");
-      } else {
-        return result;
-      }
-    }
-  }
-  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->map()->instance_type() > LAST_CUSTOM_ELEMENTS_RECEIVER &&
-      object->HasFastProperties() &&
-      Handle<JSObject>::cast(object)->elements()->length() == 0) {
-    DCHECK(object->IsJSObject());
-    DCHECK(!object->IsJSGlobalProxy());
-    Handle<JSObject> js_obj = Handle<JSObject>::cast(object);
-    DCHECK(!js_obj->HasIndexedInterceptor());
-    DCHECK(!js_obj->HasNamedInterceptor());
-    Handle<Map> map(js_obj->map());
-    builder_.AppendCharacter('{');
-    Indent();
-    bool comma = false;
-    for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
-      Handle<Name> name(map->instance_descriptors()->GetKey(i), isolate_);
-      // TODO(rossberg): Should this throw?
-      if (!name->IsString()) continue;
-      Handle<String> key = Handle<String>::cast(name);
-      PropertyDetails details = map->instance_descriptors()->GetDetails(i);
-      if (details.IsDontEnum()) continue;
-      Handle<Object> property;
-      if (details.type() == DATA && *map == js_obj->map()) {
-        FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
-        if (js_obj->IsUnboxedDoubleField(field_index)) {
-          double value = js_obj->RawFastDoublePropertyAt(field_index);
-          property = isolate_->factory()->NewHeapNumber(value);
-        } else {
-          property = handle(js_obj->RawFastPropertyAt(field_index), isolate_);
-        }
-      } else {
-        ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-            isolate_, property, Object::GetPropertyOrElement(js_obj, key),
-            EXCEPTION);
-      }
-      Result result = SerializeProperty(property, comma, key);
-      if (!comma && result == SUCCESS) comma = true;
-      if (result == EXCEPTION) return result;
-    }
-    Unindent();
-    if (comma) NewLine();
-    builder_.AppendCharacter('}');
-  } else {
-    Result result = SerializeJSReceiverSlow(object);
-    if (result != SUCCESS) return result;
-  }
-  StackPop();
-  return SUCCESS;
-}
-
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSReceiverSlow(
-    Handle<JSReceiver> object) {
-  Handle<FixedArray> contents;
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, contents,
-      JSReceiver::GetKeys(object, OWN_ONLY, ENUMERABLE_STRINGS), EXCEPTION);
-
-  builder_.AppendCharacter('{');
-  Indent();
-  bool comma = false;
-  for (int i = 0; i < contents->length(); i++) {
-    Object* key = contents->get(i);
-    Handle<String> key_handle;
-    MaybeHandle<Object> maybe_property;
-    if (key->IsString()) {
-      key_handle = Handle<String>(String::cast(key), isolate_);
-      maybe_property = Object::GetPropertyOrElement(object, key_handle);
-    } else {
-      DCHECK(key->IsNumber());
-      key_handle = factory()->NumberToString(Handle<Object>(key, isolate_));
-      if (key->IsSmi()) {
-        maybe_property =
-            JSReceiver::GetElement(isolate_, object, Smi::cast(key)->value());
-      } else {
-        maybe_property = Object::GetPropertyOrElement(object, key_handle);
-      }
-    }
-    Handle<Object> property;
-    ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, property, maybe_property,
-                                     EXCEPTION);
-    Result result = SerializeProperty(property, comma, key_handle);
-    if (!comma && result == SUCCESS) comma = true;
-    if (result == EXCEPTION) return result;
-  }
-  Unindent();
-  if (comma) NewLine();
-  builder_.AppendCharacter('}');
-  return SUCCESS;
-}
-
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSProxy(
-    Handle<JSProxy> object) {
-  Result stack_push = StackPush(object);
-  if (stack_push != SUCCESS) return stack_push;
-  Maybe<bool> is_array = Object::IsArray(object);
-  if (is_array.IsNothing()) return EXCEPTION;
-  if (is_array.FromJust()) {
-    Handle<Object> length_object;
-    ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-        isolate_, length_object,
-        Object::GetLengthFromArrayLike(isolate_, object), EXCEPTION);
-    uint32_t length;
-    if (!length_object->ToUint32(&length)) {
-      // Technically, we need to be able to handle lengths outside the
-      // uint32_t range. However, we would run into string size overflow
-      // if we tried to stringify such an array.
-      isolate_->Throw(*isolate_->factory()->NewInvalidStringLengthError());
-      return EXCEPTION;
-    }
-    builder_.AppendCharacter('[');
-    Indent();
-    Result result = SerializeArrayLikeSlow(object, 0, length);
-    if (result != SUCCESS) return result;
-    Unindent();
-    if (length > 0) NewLine();
-    builder_.AppendCharacter(']');
-  } else {
-    Result result = SerializeJSReceiverSlow(object);
-    if (result != SUCCESS) return result;
-  }
-  StackPop();
-  return SUCCESS;
-}
-
-
-template <typename SrcChar, typename DestChar>
-void BasicJsonStringifier::SerializeStringUnchecked_(
-    Vector<const SrcChar> src,
-    IncrementalStringBuilder::NoExtend<DestChar>* dest) {
-  // Assert that uc16 character is not truncated down to 8 bit.
-  // The <uc16, char> version of this method must not be called.
-  DCHECK(sizeof(DestChar) >= sizeof(SrcChar));
-
-  for (int i = 0; i < src.length(); i++) {
-    SrcChar c = src[i];
-    if (DoNotEscape(c)) {
-      dest->Append(c);
-    } else {
-      dest->AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
-    }
-  }
-}
-
-
-template <typename SrcChar, typename DestChar>
-void BasicJsonStringifier::SerializeString_(Handle<String> string) {
-  int length = string->length();
-  builder_.Append<uint8_t, DestChar>('"');
-  // We make a rough estimate to find out if the current string can be
-  // serialized without allocating a new string part. The worst case length of
-  // an escaped character is 6.  Shifting the remainin string length right by 3
-  // is a more pessimistic estimate, but faster to calculate.
-  int worst_case_length = length << 3;
-  if (builder_.CurrentPartCanFit(worst_case_length)) {
-    DisallowHeapAllocation no_gc;
-    Vector<const SrcChar> vector = string->GetCharVector<SrcChar>();
-    IncrementalStringBuilder::NoExtendBuilder<DestChar> no_extend(
-        &builder_, worst_case_length);
-    SerializeStringUnchecked_(vector, &no_extend);
-  } else {
-    FlatStringReader reader(isolate_, string);
-    for (int i = 0; i < reader.length(); i++) {
-      SrcChar c = reader.Get<SrcChar>(i);
-      if (DoNotEscape(c)) {
-        builder_.Append<SrcChar, DestChar>(c);
-      } else {
-        builder_.AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
-      }
-    }
-  }
-
-  builder_.Append<uint8_t, DestChar>('"');
-}
-
-
-template <>
-bool BasicJsonStringifier::DoNotEscape(uint8_t c) {
-  return c >= '#' && c <= '~' && c != '\\';
-}
-
-
-template <>
-bool BasicJsonStringifier::DoNotEscape(uint16_t c) {
-  return c >= '#' && c != '\\' && c != 0x7f;
-}
-
-void BasicJsonStringifier::NewLine() {
-  if (gap_ == nullptr) return;
-  builder_.AppendCharacter('\n');
-  for (int i = 0; i < indent_; i++) builder_.AppendCString(gap_);
-}
-
-void BasicJsonStringifier::SerializeString(Handle<String> object) {
-  object = String::Flatten(object);
-  if (builder_.CurrentEncoding() == String::ONE_BYTE_ENCODING) {
-    if (object->IsOneByteRepresentationUnderneath()) {
-      SerializeString_<uint8_t, uint8_t>(object);
-    } else {
-      builder_.ChangeEncoding();
-      SerializeString(object);
-    }
-  } else {
-    if (object->IsOneByteRepresentationUnderneath()) {
-      SerializeString_<uint8_t, uc16>(object);
-    } else {
-      SerializeString_<uc16, uc16>(object);
-    }
-  }
-}
-
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_JSON_STRINGIFIER_H_