Extend constructor inlining test case.

test/mjsunit/compiler/inline-construct.js

 // Copyright 2012 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 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Flags: --allow-natives-syntax --inline-construct
 
 // Test inlining of constructor calls.
 
 function TestInlinedConstructor(constructor, closure) {
   var result;
   var counter = { value:0 };
+  var noDeopt = { deopt:0 };
+  var forceDeopt = { /*empty*/ };
 
-  result = closure(constructor, 11, 12, counter);
-  assertEquals(23, result);
+  result = closure(constructor, 11, noDeopt, counter);
+  assertEquals(11, result);
   assertEquals(1, counter.value);
 
-  result = closure(constructor, 23, 19, counter);
-  assertEquals(42, result);
+  result = closure(constructor, 23, noDeopt, counter);
+  assertEquals(23, result);
   assertEquals(2, counter.value);
 
   %OptimizeFunctionOnNextCall(closure);
-  result = closure(constructor, 1, 42, counter);
-  assertEquals(43, result);
+  result = closure(constructor, 42, noDeopt, counter);
+  assertEquals(42, result);
   assertEquals(3, counter.value);
 
-  result = closure(constructor, "foo", "bar", counter);
-  assertEquals("foobar", result)
+  result = closure(constructor, 127, forceDeopt, counter);
+  assertEquals(127, result)
   assertEquals(4, counter.value);
 
   %DeoptimizeFunction(closure);
   %ClearFunctionTypeFeedback(closure);
+  %ClearFunctionTypeFeedback(constructor);
 }
 
-function value_context(constructor, a, b, counter) {
-  var obj = new constructor(a, b, counter);
+function value_context(constructor, val, deopt, counter) {
+  var obj = new constructor(val, deopt, counter);
   return obj.x;
 }
 
-function test_context(constructor, a, b, counter) {
-  if (!new constructor(a, b, counter)) {
+function test_context(constructor, val, deopt, counter) {
+  if (!new constructor(val, deopt, counter)) {
     assertUnreachable("should not happen");
   }
-  return a + b;
+  return val;
 }
 
-function effect_context(constructor, a, b, counter) {
-  new constructor(a, b, counter);
-  return a + b;
+function effect_context(constructor, val, deopt, counter) {
+  new constructor(val, deopt, counter);
+  return val;
 }
 
 function TestInAllContexts(constructor) {
   TestInlinedConstructor(constructor, value_context);
   TestInlinedConstructor(constructor, test_context);
   TestInlinedConstructor(constructor, effect_context);
 }
 
 
 // Test constructor returning nothing in all contexts.
-function c1(a, b, counter) {
-  this.x = a + b;
+function c1(val, deopt, counter) {
+  deopt.deopt;
+  this.x = val;
   counter.value++;
 }
 TestInAllContexts(c1);
 
 
 // Test constructor returning an object in all contexts.
-function c2(a, b, counter) {
+function c2(val, deopt, counter) {
   var obj = {};
-  obj.x = a + b;
+  deopt.deopt;
+  obj.x = val;
   counter.value++;
   return obj;
 }
 TestInAllContexts(c2);
 
 
 // Test constructor returning a primitive value in all contexts.
-function c3(a, b, counter) {
-  this.x = a + b;
+function c3(val, deopt, counter) {
+  deopt.deopt;
+  this.x = val;
   counter.value++;
   return "not an object";
 }
 TestInAllContexts(c3);
 
 
 // Test constructor called with too many arguments.
 function c_too_many(a, b) {
   this.x = a + b;
 }
@@ skipping 18 matching lines @@
   return obj.x;
 }
 assertEquals(12, f_too_few(11));
 assertEquals(24, f_too_few(23));
 %OptimizeFunctionOnNextCall(f_too_few);
 assertEquals(2, f_too_few(1));
 assertEquals("foo1", f_too_few("foo"))
 
 
 // Test constructor that cannot be inlined.
-function c_unsupported_syntax(a, b, counter) {
+function c_unsupported_syntax(val, deopt, counter) {
   try {
-    this.x = a + b;
+    deopt.deopt;
+    this.x = val;
     counter.value++;
   } catch(e) {
     throw new Error();
   }
 }
 TestInAllContexts(c_unsupported_syntax);
 
 
 // Regression test: Inlined constructors called as functions do not get their
 // implicit receiver object set to undefined, even in strict mode.
-function c_strict(a, b, counter) {
+function c_strict(val, deopt, counter) {
   "use strict";
-  this.x = a + b;
+  deopt.deopt;
+  this.x = val;
   counter.value++;
 }
 TestInAllContexts(c_strict);