dart2js cps: More aggressive operator specialization.

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

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library cps_ir.optimization.inline;
 
 import 'cps_fragment.dart';
 import 'cps_ir_builder.dart' show ThisParameterLocal;
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
@@ skipping 387 matching lines @@
       return null;
     }
 
     // Don't inline methods that never return. They are usually helper functions
     // that throw an exception.
     if (invoke.type.isEmpty && !invoke.type.isNullable) {
       // TODO(sra): It would be ok to inline if doing so was shrinking.
       return null;
     }
 
+    if (isBlacklisted(target)) return null;
+
+    if (invoke.callingConvention == CallingConvention.OneShotIntercepted) {
+      // One-shot interceptor calls with a known target are only inserted on
+      // uncommon code paths, so they should not be inlined.
+      return null;
+    }
+
     Reference<Primitive> dartReceiver = invoke.dartReceiverReference;
     TypeMask abstractReceiver =
         dartReceiver == null ? null : abstractType(dartReceiver);
     // The receiver is non-null in a method body, unless the receiver is known
     // to be `null` (isEmpty covers `null` and unreachable).
     TypeMask abstractReceiverInMethod = abstractReceiver == null
         ? null
         : abstractReceiver.isEmpty
             ? abstractReceiver
             : abstractReceiver.nonNullable();
@@ skipping 87 matching lines @@
 
     _inliner.cache.putPositive(target, callStructure, abstractReceiverInMethod,
         abstractArguments, function);
     return finish(function);
   }
 
   Primitive nullReceiverGuard(InvocationPrimitive invoke,
                               CpsFragment fragment,
                               Primitive dartReceiver,
                               TypeMask abstractReceiver) {
-    Selector selector = invoke is InvokeMethod ? invoke.selector : null;
+    if (invoke is! InvokeMethod) return dartReceiver;
+    InvokeMethod invokeMethod = invoke;
+    Selector selector = invokeMethod.selector;
     if (typeSystem.isDefinitelyNum(abstractReceiver, allowNull: true)) {
       Primitive condition = _fragment.letPrim(
           new ApplyBuiltinOperator(BuiltinOperator.IsNotNumber,
                                    <Primitive>[dartReceiver],
                                    invoke.sourceInformation));
       condition.type = typeSystem.boolType;
       Primitive check = _fragment.letPrim(
-          new NullCheck.guarded(
-              condition, dartReceiver, selector, invoke.sourceInformation));
+          new ReceiverCheck.nullCheck(dartReceiver, selector,
+              invoke.sourceInformation,
+              condition: condition));
       check.type = abstractReceiver.nonNullable();
       return check;
     }
 
     Primitive check = _fragment.letPrim(
-        new NullCheck(dartReceiver, invoke.sourceInformation,
-                      selector: selector));
+        new ReceiverCheck.nullCheck(dartReceiver, selector,
+            invoke.sourceInformation));
     check.type = abstractReceiver.nonNullable();
     return check;
   }
 
 
   @override
   Primitive visitInvokeStatic(InvokeStatic node) {
     return tryInlining(node, node.target, null);
   }
 
@@ skipping 22 matching lines @@
     if (node.dartType is GenericType) {
       // We cannot inline a constructor invocation containing type arguments
       // because CreateInstance in the body does not know the type arguments.
       // We would incorrectly instantiate a class like A instead of A<B>.
       // TODO(kmillikin): try to fix this.
       GenericType generic = node.dartType;
       if (generic.typeArguments.any((DartType t) => !t.isDynamic)) return null;
     }
     return tryInlining(node, node.target, null);
   }
+
+  bool isBlacklisted(FunctionElement target) {
+    ClassElement enclosingClass = target.enclosingClass;
+    if (target.isOperator &&
+        (enclosingClass == backend.helpers.jsNumberClass ||
+         enclosingClass == backend.helpers.jsDoubleClass ||
+         enclosingClass == backend.helpers.jsIntClass)) {
+      // These should be handled by operator specialization.
+      return true;
+    }
+    return false;
+  }
 }