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) {

[Siggi Cherem (dart-lang), 2016/02/05 18:19:39]

Is this mainly for the one-shot interceptors you introduce in the
transformation? I wonder about whether this also has an effects on perf on its
own, in which case it might be worth submitting this line change on its own
first to know what is the baseline to compare against?

[asgerf, 2016/02/09 12:19:54]

Regular one-shot interceptors are inserted later in the pipeline, so the only
one affected should be the one we used for bailout.  A more general solution is
to not inline code on throwing paths, which is on the TODO list.

+      // 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;
+  }
 }