[crankshaft] Do not optimize ClassConstructor calls and apply.

test/mjsunit/es6/classes.js

 // Copyright 2014 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.
 
-// Flags: --harmony-sloppy
+// Flags: --harmony-sloppy --allow-natives-syntax
 
 (function TestBasics() {
   var C = class C {}
   assertEquals(typeof C, 'function');
   assertEquals(C.__proto__, Function.prototype);
   assertEquals(Object.prototype, Object.getPrototypeOf(C.prototype));
   assertEquals(Function.prototype, Object.getPrototypeOf(C));
   assertEquals('C', C.name);
 
   class D {}
@@ skipping 602 matching lines @@
 
 (function TestDefaultConstructorNoCrash() {
   // Regression test for https://code.google.com/p/v8/issues/detail?id=3661
   class C {}
   assertThrows(function () {C();}, TypeError);
   assertThrows(function () {C(1);}, TypeError);
   assertTrue(new C() instanceof C);
   assertTrue(new C(1) instanceof C);
 })();
 
+
 (function TestConstructorCall(){
   var realmIndex = Realm.create();
   var otherTypeError = Realm.eval(realmIndex, "TypeError");
   var A = Realm.eval(realmIndex, '"use strict"; class A {}');
   var instance = new A();
   var constructor = instance.constructor;
   var otherTypeError = Realm.eval(realmIndex, 'TypeError');
   if (otherTypeError === TypeError) {
     throw Error('Should not happen!');
   }
 
   // ES6 9.2.1[[Call]] throws a TypeError in the caller context/Realm when the
   // called function is a classConstructor
   assertThrows(function() { Realm.eval(realmIndex, "A()") }, otherTypeError);
   assertThrows(function() { instance.constructor() }, TypeError);
   assertThrows(function() { A() }, TypeError);
 
   // ES6 9.3.1 call() first activates the callee context before invoking the
   // method. The TypeError from the constructor is thus thrown in the other
   // Realm.
   assertThrows(function() { Realm.eval(realmIndex, "A.call()") },
       otherTypeError);
   assertThrows(function() { constructor.call() }, otherTypeError);
   assertThrows(function() { A.call() }, otherTypeError);
 })();
 
+
+(function TestConstructorCallOptimized() {
+  class A { };
+
+  function invoke_constructor() { A() }
+  function call_constructor() { A.call() }
+  function apply_constructor() { A.apply() }
+
+  for (var i=0; i<3; i++) {
+    assertThrows(invoke_constructor);
+    assertThrows(call_constructor);
+    assertThrows(apply_constructor);
+  }
+  // Make sure we still check for class constructors when calling optimized
+  // code.
+  %OptimizeFunctionOnNextCall(invoke_constructor);
+  assertThrows(invoke_constructor);
+  %OptimizeFunctionOnNextCall(call_constructor);
+  assertThrows(call_constructor);
+  %OptimizeFunctionOnNextCall(apply_constructor);
+  assertThrows(apply_constructor);
+})();
+
+
 (function TestDefaultConstructor() {
   var calls = 0;
   class Base {
     constructor() {
       calls++;
     }
   }
   class Derived extends Base {}
   var object = new Derived;
   assertEquals(1, calls);
@@ skipping 300 matching lines @@
   testClassRestrictedProperties(ClassWithDefaultConstructor);
   testClassRestrictedProperties(Class);
   testClassRestrictedProperties(DerivedClassWithDefaultConstructor);
   testClassRestrictedProperties(DerivedClass);
   testClassRestrictedProperties(class { method() {} });
   testClassRestrictedProperties(class { constructor() {} method() {} });
   testClassRestrictedProperties(class extends Class { });
   testClassRestrictedProperties(
       class extends Class { constructor() { super(); } });
 })();