[es6] Implement Date.prototype[@@toPrimitive] as C++ builtin.

src/objects.cc

 // Copyright 2013 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/objects.h"
 
 #include <iomanip>
 #include <sstream>
 
 #include "src/accessors.h"
@@ skipping 6023 matching lines @@
     Handle<Object> result;
     ASSIGN_RETURN_ON_EXCEPTION(
         isolate, result,
         Execution::Call(isolate, exotic_to_prim, receiver, 1, &hint_string),
         Object);
     if (result->IsPrimitive()) return result;
     THROW_NEW_ERROR(isolate,
                     NewTypeError(MessageTemplate::kCannotConvertToPrimitive),
                     Object);
   }
-  return OrdinaryToPrimitive(receiver,
-                             (hint == ToPrimitiveHint::kString)
-                                 ? isolate->factory()->string_string()
-                                 : isolate->factory()->number_string());
+  return OrdinaryToPrimitive(receiver, (hint == ToPrimitiveHint::kString)
+                                           ? OrdinaryToPrimitiveHint::kString
+                                           : OrdinaryToPrimitiveHint::kNumber);
 }
 
 
 // static
-MaybeHandle<Object> JSReceiver::OrdinaryToPrimitive(Handle<JSReceiver> receiver,
-                                                    Handle<String> hint) {
+MaybeHandle<Object> JSReceiver::OrdinaryToPrimitive(
+    Handle<JSReceiver> receiver, OrdinaryToPrimitiveHint hint) {
   Isolate* const isolate = receiver->GetIsolate();
   Handle<String> method_names[2];
-  if (hint.is_identical_to(isolate->factory()->number_string())) {
-    method_names[0] = isolate->factory()->valueOf_string();
-    method_names[1] = isolate->factory()->toString_string();
-  } else {
-    DCHECK(hint.is_identical_to(isolate->factory()->string_string()));
-    method_names[0] = isolate->factory()->toString_string();
-    method_names[1] = isolate->factory()->valueOf_string();
+  switch (hint) {
+    case OrdinaryToPrimitiveHint::kNumber:
+      method_names[0] = isolate->factory()->valueOf_string();
+      method_names[1] = isolate->factory()->toString_string();
+      break;
+    case OrdinaryToPrimitiveHint::kString:
+      method_names[0] = isolate->factory()->toString_string();
+      method_names[1] = isolate->factory()->valueOf_string();
+      break;
   }
   for (Handle<String> name : method_names) {
     Handle<Object> method;
     ASSIGN_RETURN_ON_EXCEPTION(isolate, method,
                                JSReceiver::GetProperty(receiver, name), Object);
     if (method->IsCallable()) {
       Handle<Object> result;
       ASSIGN_RETURN_ON_EXCEPTION(
           isolate, result, Execution::Call(isolate, method, receiver, 0, NULL),
           Object);
@@ skipping 2270 matching lines @@
 }
 #endif
 
 
 bool String::LooksValid() {
   if (!GetIsolate()->heap()->Contains(this)) return false;
   return true;
 }
 
 
+// static
+Handle<String> Name::ToFunctionName(Handle<Name> name) {
+  if (name->IsString()) return Handle<String>::cast(name);
+  // ES6 section 9.2.11 SetFunctionName, step 4.
+  Isolate* const isolate = name->GetIsolate();
+  Handle<Object> description(Handle<Symbol>::cast(name)->name(), isolate);
+  if (description->IsUndefined()) return isolate->factory()->empty_string();
+  int description_length = 0;
+  base::SmartArrayPointer<char> description_bytes =
+      Handle<String>::cast(description)
+          ->ToCString(ALLOW_NULLS, FAST_STRING_TRAVERSAL, 0, -1,
+                      &description_length);
+  ScopedVector<char> name_string(description_length + 2);
+  name_string[0] = '[';
+  for (int i = 0; i < description_length; ++i) {
+    name_string[i + 1] = description_bytes[i];
+  }
+  name_string[description_length + 1] = ']';
+  return isolate->factory()->InternalizeUtf8String(
+      Vector<const char>(name_string.start(), name_string.length()));
+}
+
+
 namespace {
 
 bool AreDigits(const uint8_t* s, int from, int to) {
   for (int i = from; i < to; i++) {
     if (s[i] < '0' || s[i] > '9') return false;
   }
 
   return true;
 }
 
@@ skipping 7496 matching lines @@
     set_hour(nan, SKIP_WRITE_BARRIER);
     set_min(nan, SKIP_WRITE_BARRIER);
     set_sec(nan, SKIP_WRITE_BARRIER);
     set_weekday(nan, SKIP_WRITE_BARRIER);
   } else {
     set_cache_stamp(Smi::FromInt(DateCache::kInvalidStamp), SKIP_WRITE_BARRIER);
   }
 }
 
 
+// static
+MaybeHandle<Object> JSDate::ToPrimitive(Handle<JSReceiver> receiver,
+                                        Handle<Object> hint) {
+  Isolate* const isolate = receiver->GetIsolate();
+  if (hint->IsString()) {
+    Handle<String> hint_string = Handle<String>::cast(hint);
+    if (hint_string->Equals(isolate->heap()->number_string())) {
+      return JSReceiver::OrdinaryToPrimitive(receiver,
+                                             OrdinaryToPrimitiveHint::kNumber);
+    }
+    if (hint_string->Equals(isolate->heap()->default_string()) ||
+        hint_string->Equals(isolate->heap()->string_string())) {
+      return JSReceiver::OrdinaryToPrimitive(receiver,
+                                             OrdinaryToPrimitiveHint::kString);
+    }
+  }
+  THROW_NEW_ERROR(isolate, NewTypeError(MessageTemplate::kInvalidHint, hint),
+                  Object);
+}
+
+
 void JSDate::SetCachedFields(int64_t local_time_ms, DateCache* date_cache) {
   int days = DateCache::DaysFromTime(local_time_ms);
   int time_in_day_ms = DateCache::TimeInDay(local_time_ms, days);
   int year, month, day;
   date_cache->YearMonthDayFromDays(days, &year, &month, &day);
   int weekday = date_cache->Weekday(days);
   int hour = time_in_day_ms / (60 * 60 * 1000);
   int min = (time_in_day_ms / (60 * 1000)) % 60;
   int sec = (time_in_day_ms / 1000) % 60;
   set_cache_stamp(date_cache->stamp());
@@ skipping 247 matching lines @@
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 
 }  // namespace internal
 }  // namespace v8