Add a new class InvokeDynamicSpecializer and subclasses that know what input types are beneficial f…

sdk/lib/_internal/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 1302 matching lines @@
   }
 }
 
 class HInvokeClosure extends HInvokeDynamic {
   HInvokeClosure(Selector selector, List<HInstruction> inputs)
     : super(selector, null, inputs);
   accept(HVisitor visitor) => visitor.visitInvokeClosure(this);
 }
 
 class HInvokeDynamicMethod extends HInvokeDynamic {
-  HInvokeDynamicMethod(Selector selector, List<HInstruction> inputs)
-    : super(selector, null, inputs);
+  final InvokeDynamicSpecializer specializer;
+  HInvokeDynamicMethod(Selector selector,
+                       List<HInstruction> inputs,
+                       [bool isIntercepted = false])
+    : super(selector, null, inputs),
+      specializer = isIntercepted
+          ? InvokeDynamicSpecializer.lookupSpecializer(selector)
+          : const InvokeDynamicSpecializer();
   String toString() => 'invoke dynamic method: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicMethod(this);
 
   bool isIndexOperatorOnIndexablePrimitive(HTypeMap types) {
     return isInterceptorCall
         && selector.kind == SelectorKind.INDEX
         && selector.name == const SourceString('[]')
         && inputs[1].isIndexablePrimitive(types);
   }
 
   HType computeDesiredTypeForInput(HInstruction input,
                                    HTypeMap types,
                                    Compiler compiler) {
-    // TODO(ngeoffray): Move this logic into a different class that
-    // will know what type it wants for a given selector.
-    if (!isInterceptorCall) return HType.UNKNOWN;
-
-    if (selector.kind == SelectorKind.INDEX) {
-      HInstruction index = inputs[2];
-      if (input == inputs[1] &&
-          (index.isTypeUnknown(types) || index.isNumber(types))) {
-        return selector.name == const SourceString('[]')
-            ? HType.INDEXABLE_PRIMITIVE
-            : HType.MUTABLE_ARRAY;
-      }
-      // The index should be an int when the receiver is a string or array.
-      // However it turns out that inserting an integer check in the optimized
-      // version is cheaper than having another bailout case. This is true,
-      // because the integer check will simply throw if it fails.
-      return HType.UNKNOWN;
-    } else if (selector.kind == SelectorKind.OPERATOR) {
-      HType propagatedType = types[this];
-      if (selector.name == const SourceString('unary-') && input == inputs[1]) {
-        // If the outgoing type should be a number (integer, double or both) we
-        // want the outgoing type to be the input too.
-        // If we don't know the outgoing type we try to make it a number.
-        if (propagatedType.isNumber()) return propagatedType;
-        if (propagatedType.isUnknown()) return HType.NUMBER;
-      } else if (selector.name == const SourceString('~')
-                 && input == inputs[1]) {
-        if (propagatedType.isUnknown() || propagatedType.isNumber()) {
-          return HType.INTEGER;
-        }
-      }
-      return HType.UNKNOWN;
-    }
-    return HType.UNKNOWN;
+    return specializer.computeDesiredTypeForInput(this, input, types, compiler);
   }
 
   HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
-    // TODO(ngeoffray): Move this logic into a different class that
-    // will know what type it has for a given selector.
-    if (!isInterceptorCall) return HType.UNKNOWN;
-
-    if (selector.kind == SelectorKind.OPERATOR) {
-      if (selector.name == const SourceString('unary-')) {
-        HType operandType = types[inputs[1]];
-        if (operandType.isNumber()) return operandType;
-      } else if (selector.name == const SourceString('~')) {
-        // All bitwise operations on primitive types either produce an
-        // integer or throw an error.
-        if (inputs[1].isPrimitive(types)) return HType.INTEGER;
-      }
-    }
-    return HType.UNKNOWN;
+    return specializer.computeTypeFromInputTypes(this, types, compiler);
   }
 }
 
 abstract class HInvokeDynamicField extends HInvokeDynamic {
   final bool isSideEffectFree;
   HInvokeDynamicField(
       Selector selector, Element element, List<HInstruction> inputs,
       this.isSideEffectFree)
       : super(selector, element, inputs);
   toString() => 'invoke dynamic field: $selector';
@@ skipping 1532 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }