Implement ES6 Array.of()

src/runtime.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 <stdlib.h>
 #include <limits>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 7786 matching lines @@
   if (y == 0) {
     return Smi::FromInt(1);
   } else {
     double result = power_double_double(x, y);
     if (std::isnan(result)) return isolate->heap()->nan_value();
     return *isolate->factory()->NewNumber(result);
   }
 }
 
 
+RUNTIME_FUNCTION(Runtime_IsConstructor) {

[rossberg, 2014/07/08 08:39:17]

Drive-by-comment: Unfortunately, I don't think this function is quite correct.
For example, it does not handle function proxies.

[rossberg, 2014/07/08 09:59:09]

And more importantly, for JSFunctions it is testing whether they _have_ a
constructor, not whether they _are_ one -- completely different thing
(GetConstructor will normally return Function.prototype in this case).

So, this whole function is completely wrong. Unfortunately, it's not so simple
to implement it correctly either. You can have a look at Runtime_NewObjectHelper
in runtime.cc to get an idea. But if we actually need such a predicate, then the
condition used there should be properly refactored. For now, I would prefer just
to fall back to IS_SPEC_FUNCTION.

+  HandleScope scope(isolate);
+  ASSERT(args.length() == 1);
+
+  CONVERT_ARG_CHECKED(JSFunction, obj, 0);
+  if (!obj->IsObject()) return isolate->heap()->false_value();
+  bool hasConstructor = !!obj->GetConstructor();
+  return hasConstructor ? isolate->heap()->true_value()
+                        : isolate->heap()->false_value();
+}
+
+
 RUNTIME_FUNCTION(Runtime_RoundNumber) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
   CONVERT_NUMBER_ARG_HANDLE_CHECKED(input, 0);
   isolate->counters()->math_round()->Increment();
 
   if (!input->IsHeapNumber()) {
     ASSERT(input->IsSmi());
     return *input;
   }
@@ skipping 7291 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 } }  // namespace v8::internal