dart2js cps: Better 'is int' checks.

pkg/compiler/lib/src/cps_ir/builtin_operator.dart

Index: pkg/compiler/lib/src/cps_ir/builtin_operator.dart
diff --git a/pkg/compiler/lib/src/cps_ir/builtin_operator.dart b/pkg/compiler/lib/src/cps_ir/builtin_operator.dart
index 60c1ec98b2e9700a9d148cb6919f736a3a0a3a97..0995e342cf047a1cece617ff67e4889119deee57 100644
--- a/pkg/compiler/lib/src/cps_ir/builtin_operator.dart
+++ b/pkg/compiler/lib/src/cps_ir/builtin_operator.dart
@@ -17,6 +17,11 @@ library builtin_operator;
 ///
 /// In all cases, the word "null" refers to the Dart null object, corresponding
 /// to both JS null and JS undefined.
+///
+/// Some operators, notably [IsFloor] and [IsNumberAndFloor], take "repeated"

[karlklose, 2015/06/18 07:36:56]

We could avoid this problem by adding 'typeof' and 'Math.isFloor' as builtin
operators instead.  WDYT?

[asgerf, 2015/06/18 09:08:49]

(Summary from offline discussion with Karl)

I agree that it's somewhat unusual, but I wouldn't go as far as calling it a
problem, because there really is no harm in it. It has the positive benefit of
bringing awareness to an issue that is otherwise easily overlooked.

Try to see codegen_helpers.dart:410 to see the corresponding logic in SSA. The
"complexity" was there all along, we are just tackling it head on instead of
leaving it as a subtlety for assignment propagation to think about.

But is true, with more fine-grained operators, it would go away entirely. But
there are some drawbacks to fine-grained operators:
1. They require more IR nodes at runtime.
2. Building complex expressions is more complicated than just adding one
operator.
3. Analyzing the resulting IR is harder. The IR for IsNumberAndFloor would
require two LetConts and a Branch, and then it's much harder to see that it just
checks if a value is an integer.

+/// arguments to reflect the number of times the given value is referenced
+/// by the generated code. The tree IR needs to know the number of references
+/// to safely propagate assignments.
 enum BuiltinOperator {
   /// The numeric binary operators must take two numbers as argument.
   /// The bitwise operators coerce the result to an unsigned integer, but
@@ -55,5 +60,30 @@ enum BuiltinOperator {
 
   /// Returns true if the argument is false, +0. -0, NaN, the empty string,
   /// or null.
-  IsFalsy
+  IsFalsy,
+
+  /// Returns true if the argument is a number.
+  ///
+  /// Compiles to `typeof x === 'number'`
+  IsNumber,
+
+  /// Returns true if the argument is not a number.
+  ///
+  /// Compiles to `typeof x !== 'number'`.
+  IsNotNumber,
+
+  /// Returns true if the argument is an integer, false if it is a double or
+  /// null, and unspecified if it is anything else.
+  ///
+  /// The argument must be repeated 2 times.
+  ///
+  /// Compiles to `Math.floor(x) === x`
+  IsFloor,
+
+  /// Returns true if the argument is an integer.
+  ///
+  /// The argument must be repeated 3 times.
+  ///
+  /// Compiles to `typeof x === 'number' && Math.floor(x) === x`
+  IsNumberAndFloor,
 }