[strong] Implement strong mode semantics for the count operation.

test/mjsunit/strong/implicit-conversions.js

 // Copyright 2015 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: --strong-mode --allow-natives-syntax
 
 "use strict";
 
 // Boolean indicates whether an operator can be part of a compound assignment.
 let strongNumberBinops = [
@@ skipping 43 matching lines @@
   "'0'",
   "'NaN'"
 ];
 
 let nonNumberValues = nonStringOrNumberValues.concat(stringValues);
 
 let numberValues = [
   "0",
   "(-0)",
   "1",
-  "0.79",

[rossberg, 2015/06/30 12:53:52]

Why did you remove these cases?

[conradw, 2015/06/30 14:01:10]

The runtime of this test was beginning to get excessive, and the cases I removed
weren't exercising any different paths in the IC/stub code. I wrote this test
before I knew how ICs worked so I didn't choose the most sensible values.

-  "(-0.79)",
-  "4294967295",
-  "4294967296",
   "(-4294967295)",
   "(-4294967296)",
   "9999999999999",
   "(-9999999999999)",
-  "1.5e10",
-  "(-1.5e10)",
-  "0xFFF",
-  "(-0xFFF)",
   "NaN",
   "Infinity",
   "(-Infinity)"
 ];
 
+//******************************************************************************
+// Relational comparison function declarations
 function add_strong(x, y) {
   "use strong";
   return x + y;
 }
 
 function add_num_strong(x, y) {
   "use strong";
   return x + y;
 }
 
@@ skipping 155 matching lines @@
 function typed_less_equal_strong(x, y) {
   "use strong";
   return (+x) <= (+y);
 }
 
 function typed_greater_equal_strong(x, y) {
   "use strong";
   return (+x) >= (+y);
 }
 
+//******************************************************************************
+// (in)equality function declarations
+function str_equal_strong(x, y) {
+  "use strong";
+  return x === y;
+}
+
+function str_ineq_strong(x, y) {
+  "use strong";
+  return x !== y;
+}
+
 let strongNumberFuncs = [add_num_strong, sub_strong, mul_strong, div_strong,
                          mod_strong, or_strong, and_strong, xor_strong,
                          shl_strong, shr_strong, sar_strong, less_num_strong,
                          greater_num_strong, less_equal_num_strong,
                          greater_equal_num_strong, typed_add_strong,
                          typed_sub_strong, typed_mul_strong, typed_div_strong,
                          typed_mod_strong, typed_or_strong,  typed_and_strong,
                          typed_xor_strong, typed_shl_strong, typed_shr_strong,
                          typed_sar_strong, typed_less_strong,
                          typed_greater_strong, typed_less_equal_strong,
@@ skipping 59 matching lines @@
   for (let value of numberValues) {
     assertStrongNonThrowBehaviour("(" + op + value + ")");
   }
   for (let value of nonNumberValues) {
     assertStrongThrowBehaviour("(" + op + value + ")");
   }
 }
 
 for (let func of strongNumberFuncs) {
   // Check IC None*None->None throws
-  assertThrows(function(){func(2, "foo");}, TypeError);
-  %OptimizeFunctionOnNextCall(func);
-  assertThrows(function(){func(2, "foo");}, TypeError);
-  %DeoptimizeFunction(func);
+  for (let v of nonNumberValues) {
+    let value = eval(v);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %OptimizeFunctionOnNextCall(func);
+    print(func);

[rossberg, 2015/06/30 12:53:52]

Stray debug output?

[conradw, 2015/06/30 14:01:10]

Done.

+    print(value);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %DeoptimizeFunction(func);
+  }
   func(4, 5);
   func(4, 5);
   // Check IC Smi*Smi->Smi throws
-  assertThrows(function(){func(2, "foo");}, TypeError);
-  %OptimizeFunctionOnNextCall(func);
-  assertThrows(function(){func(2, "foo");}, TypeError);
-  %DeoptimizeFunction(func);
+  for (let v of nonNumberValues) {
+    let value = eval(v);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %OptimizeFunctionOnNextCall(func);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %DeoptimizeFunction(func);
+  }
   func(NaN, NaN);
   func(NaN, NaN);
   // Check IC Number*Number->Number throws
-  assertThrows(function(){func(2, "foo");}, TypeError);
-  %OptimizeFunctionOnNextCall(func);
-  assertThrows(function(){func(2, "foo");}, TypeError);
-  %DeoptimizeFunction(func);
+  for (let v of nonNumberValues) {
+    let value = eval(v);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %OptimizeFunctionOnNextCall(func);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %DeoptimizeFunction(func);
+  }
 }
 
 for (let func of strongStringOrNumberFuncs) {
   // Check IC None*None->None throws
-  assertThrows(function(){func(2, "foo");}, TypeError);
-  %OptimizeFunctionOnNextCall(func);
-  assertThrows(function(){func(2, "foo");}, TypeError);
-  %DeoptimizeFunction(func);
+  for (let v of nonNumberValues) {
+    let value = eval(v);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %OptimizeFunctionOnNextCall(func);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %DeoptimizeFunction(func);
+  }
   func("foo", "bar");
   func("foo", "bar");
   // Check IC String*String->String throws
-  assertThrows(function(){func(2, "foo");}, TypeError);
-  %OptimizeFunctionOnNextCall(func);
-  assertThrows(function(){func(2, "foo");}, TypeError);
-  %DeoptimizeFunction(func);
+  for (let v of nonNumberValues) {
+    let value = eval(v);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %OptimizeFunctionOnNextCall(func);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %DeoptimizeFunction(func);
+  }
   func(NaN, NaN);
   func(NaN, NaN);
   // Check IC Generic*Generic->Generic throws
-  assertThrows(function(){func(2, "foo");}, TypeError);
+  for (let v of nonNumberValues) {
+    let value = eval(v);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %OptimizeFunctionOnNextCall(func);
+    assertThrows(function(){func(2, value);}, TypeError);
+    %DeoptimizeFunction(func);
+  }
+}
+
+for (let func of [str_equal_strong, str_ineq_strong]) {
+  assertDoesNotThrow(function(){func(2, undefined)});
+  assertDoesNotThrow(function(){func(2, undefined)});
   %OptimizeFunctionOnNextCall(func);
-  assertThrows(function(){func(2, "foo");}, TypeError);
+  assertDoesNotThrow(function(){func(2, undefined)});
+  %DeoptimizeFunction(func);
+  assertDoesNotThrow(function(){func(true, {})});
+  assertDoesNotThrow(function(){func(true, {})});
+  %OptimizeFunctionOnNextCall(func);
+  assertDoesNotThrow(function(){func(true, {})});
   %DeoptimizeFunction(func);
 }