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

test/mjsunit/strong/implicit-conversions-count.js

Index: test/mjsunit/strong/implicit-conversions-count.js
diff --git a/test/mjsunit/strong/implicit-conversions-count.js b/test/mjsunit/strong/implicit-conversions-count.js
new file mode 100644
index 0000000000000000000000000000000000000000..88ed3c2068cbbb5f8c6820376024701b28db8a44
--- /dev/null
+++ b/test/mjsunit/strong/implicit-conversions-count.js
@@ -0,0 +1,168 @@
+// 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";
+
+function pre_inc(x) {
+  return ++x;
+}
+
+function post_inc(x) {
+  return x++;
+}
+
+function pre_dec(x) {
+  return --x;
+}
+
+function post_dec(x) {
+  return x--;
+}
+
+function getTestFuncs() {
+  return [
+    function(x){
+      "use strong";
+      let y = x;
+      assertEquals(++y, pre_inc(x));
+      try {
+        assertEquals(x+1, y)
+      } catch (e) {
+        assertUnreachable();
+      }
+    },
+    function(x){
+      "use strong";
+      let y = x;
+      assertEquals(y++, post_inc(x));
+      try {
+        assertEquals(x+1, y)
+      } catch (e) {
+        assertUnreachable();
+      }
+    },
+    function(x){
+      "use strong";
+      let y = x;
+      assertEquals(--y, pre_dec(x));
+      try {
+        assertEquals(x-1, y)
+      } catch (e) {
+        assertUnreachable();
+      }
+    },
+    function(x){
+      "use strong";
+      let y = x;
+      assertEquals(y--, post_dec(x));
+      try {
+        assertEquals(x-1, y)
+      } catch (e) {
+        assertUnreachable();
+      }
+    },
+    function(x){
+      "use strong";
+      let obj = { foo: x };
+      let y = ++obj.foo;
+      assertEquals(y, pre_inc(x));
+      try {
+        assertEquals(x+1, obj.foo)
+      } catch (e) {
+        assertUnreachable();
+      }
+    },
+    function(x){
+      "use strong";
+      let obj = { foo: x };
+      let y = obj.foo++;
+      assertEquals(y, post_inc(x));
+      try {
+        assertEquals(x+1, obj.foo)
+      } catch (e) {
+        assertUnreachable();
+      }
+    },
+    function(x){
+      "use strong";
+      let obj = { foo: x };
+      let y = --obj.foo;
+      assertEquals(y, pre_dec(x));
+      try {
+        assertEquals(x-1, obj.foo)
+      } catch (e) {
+        assertUnreachable();
+      }
+    },
+    function(x){
+      "use strong";
+      let obj = { foo: x };
+      let y = obj.foo--;
+      assertEquals(y, post_dec(x));
+      try {
+        assertEquals(x-1, obj.foo)
+      } catch (e) {
+        assertUnreachable();
+      }
+    },
+  ];
+}
+
+let nonNumberValues = [
+  {},
+  (function(){}),
+  [],
+  (class Foo {}),
+  "",
+  "foo",
+  "NaN",
+  Object(""),
+  false,
+  null,
+  undefined
+];
+
+// Check prior input of None works
+for (let func of getTestFuncs()) {
+  for (let value of nonNumberValues) {
+    assertThrows(function(){func(value)}, TypeError);
+    assertThrows(function(){func(value)}, TypeError);
+    assertThrows(function(){func(value)}, TypeError);
+    %OptimizeFunctionOnNextCall(func);
+    assertThrows(function(){func(value)}, TypeError);
+    %DeoptimizeFunction(func);
+  }
+}
+
+// Check prior input of Smi works
+for (let func of getTestFuncs()) {
+  func(1);
+  func(1);
+  func(1);
+  for (let value of nonNumberValues) {
+    assertThrows(function(){func(value)}, TypeError);
+    assertThrows(function(){func(value)}, TypeError);
+    assertThrows(function(){func(value)}, TypeError);
+    %OptimizeFunctionOnNextCall(func);
+    assertThrows(function(){func(value)}, TypeError);
+    %DeoptimizeFunction(func);
+  }
+}
+
+// Check prior input of Number works
+for (let func of getTestFuncs()) {
+  func(9999999999999);
+  func(9999999999999);
+  func(9999999999999);
+  for (let value of nonNumberValues) {
+    assertThrows(function(){func(value)}, TypeError);
+    assertThrows(function(){func(value)}, TypeError);
+    assertThrows(function(){func(value)}, TypeError);
+    %OptimizeFunctionOnNextCall(func);
+    assertThrows(function(){func(value)}, TypeError);
+    %DeoptimizeFunction(func);
+  }
+}