Introduce a BuiltinsConstructStub that sets up new.target and does a [[call]] per ES6 9.3.2

test/mjsunit/mjsunit.js

 // Copyright 2008 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 95 matching lines @@
 // Assert that the function code is (not) optimized.  If "no sync" is passed
 // as second argument, we do not wait for the concurrent optimization thread to
 // finish when polling for optimization status.
 // Only works with --allow-natives-syntax.
 var assertOptimized;
 var assertUnoptimized;
 
 
 (function () {  // Scope for utility functions.
 
+  var ObjectPrototypeToString = Object.prototype.toString;
+  var NumberPrototypeValueOf = Number.prototype.valueOf;
+  var BooleanPrototypeValueOf = Boolean.prototype.valueOf;
+  var StringPrototypeValueOf = String.prototype.valueOf;
+  var DatePrototypeValueOf = Date.prototype.valueOf;
+  var RegExpPrototypeToString = RegExp.prototype.toString;
+  var ArrayPrototypeMap = Array.prototype.map;
+  var ArrayPrototypeJoin = Array.prototype.join;
+
   function classOf(object) {
     // Argument must not be null or undefined.
-    var string = Object.prototype.toString.call(object);
+    var string = ObjectPrototypeToString.call(object);
     // String has format [object <ClassName>].
     return string.substring(8, string.length - 1);
   }
 
 
+  function ValueOf(value) {
+    switch (classOf(value)) {
+      case "Number":
+        return NumberPrototypeValueOf.call(value);
+      case "String":
+        return StringPrototypeValueOf.call(value);
+      case "Boolean":
+        return BooleanPrototypeValueOf.call(value);
+      case "Date":
+        return DatePrototypeValueOf.call(value);
+      default:
+        return value;
+    }
+  }
+
+
   function PrettyPrint(value) {
     switch (typeof value) {
       case "string":
         return JSON.stringify(value);
       case "number":
         if (value === 0 && (1 / value) < 0) return "-0";
         // FALLTHROUGH.
       case "boolean":
       case "undefined":
       case "function":
       case "symbol":
         return String(value);
       case "object":
         if (value === null) return "null";
         var objectClass = classOf(value);
         switch (objectClass) {
-        case "Number":
-        case "String":
-        case "Boolean":
-        case "Date":
-          return objectClass + "(" + PrettyPrint(value.valueOf()) + ")";
-        case "RegExp":
-          return value.toString();
-        case "Array":
-          return "[" + value.map(PrettyPrintArrayElement).join(",") + "]";
-        case "Object":
-          break;
-        default:
-          return objectClass + "()";
+          case "Number":
+          case "String":
+          case "Boolean":
+          case "Date":
+            return objectClass + "(" + PrettyPrint(ValueOf(value)) + ")";
+          case "RegExp":
+            return RegExpPrototypeToString.call(value);
+          case "Array":
+            var mapped = ArrayPrototypeMap.call(value, PrettyPrintArrayElement);
+            var joined = ArrayPrototypeJoin.call(mapped, ",");
+            return "[" + joined + "]";
+          case "Object":
+            break;
+          default:
+            return objectClass + "()";
         }
         // [[Class]] is "Object".
         var name = value.constructor.name;
         if (name) return name + "()";
         return "Object()";
       default:
         return "-- unknown value --";
     }
   }
 
@@ skipping 41 matching lines @@
       return true;
     }
     if (typeof a !== typeof b) return false;
     if (typeof a === "number") return isNaN(a) && isNaN(b);
     if (typeof a !== "object" && typeof a !== "function") return false;
     // Neither a nor b is primitive.
     var objectClass = classOf(a);
     if (objectClass !== classOf(b)) return false;
     if (objectClass === "RegExp") {
       // For RegExp, just compare pattern and flags using its toString.
-      return (a.toString() === b.toString());
+      return RegExpPrototypeToString.call(a) ===
+             RegExpPrototypeToString.call(b);
     }
     // Functions are only identical to themselves.
     if (objectClass === "Function") return false;
     if (objectClass === "Array") {
       var elementCount = 0;
       if (a.length !== b.length) {
         return false;
       }
       for (var i = 0; i < a.length; i++) {
         if (!deepEquals(a[i], b[i])) return false;
       }
       return true;
     }
     if (objectClass === "String" || objectClass === "Number" ||
       objectClass === "Boolean" || objectClass === "Date") {
-      if (a.valueOf() !== b.valueOf()) return false;
+      if (ValueOf(a) !== ValueOf(b)) return false;
     }
     return deepObjectEquals(a, b);
   }
 
   assertSame = function assertSame(expected, found, name_opt) {
     // TODO(mstarzinger): We should think about using Harmony's egal operator
     // or the function equivalent Object.is() here.
     if (found === expected) {
       if (expected !== 0 || (1 / expected) === (1 / found)) return;
     } else if ((expected !== expected) && (found !== found)) {
@@ skipping 148 matching lines @@
     if (sync_opt === undefined) sync_opt = "";
     assertTrue(OptimizationStatus(fun, sync_opt) !== 1, name_opt);
   }
 
   assertOptimized = function assertOptimized(fun, sync_opt, name_opt) {
     if (sync_opt === undefined) sync_opt = "";
     assertTrue(OptimizationStatus(fun, sync_opt) !== 2, name_opt);
   }
 
 })();