Improved constructor inlining unit tests.

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 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (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(closure) {
+function TestInlinedConstructor(constructor, closure) {
   var result;
   var counter = { value:0 };
-  result = closure(11, 12, counter);
+
+  result = closure(constructor, 11, 12, counter);
   assertEquals(23, result);
   assertEquals(1, counter.value);
-  result = closure(23, 19, counter);
+
+  result = closure(constructor, 23, 19, counter);
   assertEquals(42, result);
   assertEquals(2, counter.value);
+
   %OptimizeFunctionOnNextCall(closure);
-  result = closure(1, 42, counter)
+  result = closure(constructor, 1, 42, counter);
   assertEquals(43, result);
   assertEquals(3, counter.value);
-  result = closure("foo", "bar", counter)
+
+  result = closure(constructor, "foo", "bar", counter);
   assertEquals("foobar", result)
   assertEquals(4, counter.value);
+
+  %DeoptimizeFunction(closure);
+  %ClearFunctionTypeFeedback(closure);
+}
+
+function value_context(constructor, a, b, counter) {
+  var obj = new constructor(a, b, counter);
+  return obj.x;
+}
+
+function test_context(constructor, a, b, counter) {
+  if (!new constructor(a, b, counter)) {
+    assertUnreachable("should not happen");
+  }
+  return a + b;
+}
+
+function effect_context(constructor, a, b, counter) {
+  new constructor(a, b, counter);
+  return a + b;
 }
 
 function TestInAllContexts(constructor) {
-  function value_context(a, b, counter) {
-    var obj = new constructor(a, b, counter);
-    return obj.x;
-  }
-  function test_context(a, b, counter) {
-    if (!new constructor(a, b, counter)) {
-      assertUnreachable("should not happen");
-    }
-    return a + b;
-  }
-  function effect_context(a, b, counter) {
-    new constructor(a, b, counter);
-    return a + b;
-  }
-  TestInlinedConstructor(value_context);
-  TestInlinedConstructor(test_context);
-  TestInlinedConstructor(effect_context);
-  %DeoptimizeFunction(value_context);
-  %DeoptimizeFunction(test_context);
-  %DeoptimizeFunction(effect_context);
-  %ClearFunctionTypeFeedback(value_context);
-  %ClearFunctionTypeFeedback(test_context);
-  %ClearFunctionTypeFeedback(effect_context);
+  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;
   counter.value++;
 }
 TestInAllContexts(c1);
 
 
 // Test constructor returning an object in all contexts.
 function c2(a, b, counter) {
-  var obj = new Object();
+  var obj = {};
   obj.x = a + b;
   counter.value++;
   return obj;
 }
 TestInAllContexts(c2);
 
 
 // Test constructor returning a primitive value in all contexts.
 function c3(a, b, counter) {
   this.x = a + b;
@@ skipping 47 matching lines @@
 
 
 // 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) {
   "use strict";
   this.x = a + b;
   counter.value++;
 }
 TestInAllContexts(c_strict);