Split TypedSelector into Selector and TypeMask.

pkg/compiler/lib/src/ssa/optimize.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 OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 283 matching lines @@
           : foldBinary(operation, node.inputs[1], node.inputs[2]);
       if (instruction != null) return instruction;
     }
 
     // Try converting the instruction to a builtin instruction.
     HInstruction instruction =
         node.specializer.tryConvertToBuiltin(node, compiler);
     if (instruction != null) return instruction;
 
     Selector selector = node.selector;
+    TypeMask mask = node.mask;
     HInstruction input = node.inputs[1];
 
     World world = compiler.world;
+
+    bool applies(Element element) {
+      return selector.applies(element, world) &&
+             (mask == null || mask.canHit(element, selector, world));
+    }
+
     if (selector.isCall || selector.isOperator) {
       Element target;
       if (input.isExtendableArray(compiler)) {
-        if (selector.applies(backend.jsArrayRemoveLast, world)) {
+        if (applies(backend.jsArrayRemoveLast)) {
           target = backend.jsArrayRemoveLast;
-        } else if (selector.applies(backend.jsArrayAdd, world)) {
+        } else if (applies(backend.jsArrayAdd)) {
           // The codegen special cases array calls, but does not
           // inline argument type checks.
           if (!compiler.enableTypeAssertions) {
             target = backend.jsArrayAdd;
           }
         }
       } else if (input.isStringOrNull(compiler)) {
-        if (selector.applies(backend.jsStringSplit, world)) {
+        if (applies(backend.jsStringSplit)) {
           HInstruction argument = node.inputs[2];
           if (argument.isString(compiler)) {
             target = backend.jsStringSplit;
           }
-        } else if (selector.applies(backend.jsStringOperatorAdd, world)) {
+        } else if (applies(backend.jsStringOperatorAdd)) {
           // `operator+` is turned into a JavaScript '+' so we need to
           // make sure the receiver and the argument are not null.
           // TODO(sra): Do this via [node.specializer].
           HInstruction argument = node.inputs[2];
           if (argument.isString(compiler)
               && !input.canBeNull()) {
             return new HStringConcat(input, argument, null,
                                      node.instructionType);
           }
-        } else if (selector.applies(backend.jsStringToString, world)
+        } else if (applies(backend.jsStringToString)
                    && !input.canBeNull()) {
           return input;
         }
       }
       if (target != null) {
         // TODO(ngeoffray): There is a strong dependency between codegen
         // and this optimization that the dynamic invoke does not need an
         // interceptor. We currently need to keep a
         // HInvokeDynamicMethod and not create a HForeign because
         // HForeign is too opaque for the SsaCheckInserter (that adds a
         // bounds check on removeLast). Once we start inlining, the
         // bounds check will become explicit, so we won't need this
         // optimization.
         HInvokeDynamicMethod result = new HInvokeDynamicMethod(
-            node.selector, node.inputs.sublist(1), node.instructionType);
+            node.selector, node.mask,
+            node.inputs.sublist(1), node.instructionType);
         result.element = target;
         return result;
       }
     } else if (selector.isGetter) {
-      if (selector.asUntyped.applies(backend.jsIndexableLength, world)) {
+      if (selector.applies(backend.jsIndexableLength, world)) {
         HInstruction optimized = tryOptimizeLengthInterceptedGetter(node);
         if (optimized != null) return optimized;
       }
     }
 
     return node;
   }
 
   HInstruction visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
 
     TypeMask receiverType = node.getDartReceiver(compiler).instructionType;
-    Selector selector =
-        new TypedSelector(receiverType, node.selector, compiler.world);
-    Element element = compiler.world.locateSingleElement(selector);
+    Element element =
+        compiler.world.locateSingleElement(node.selector, receiverType);
     // TODO(ngeoffray): Also fold if it's a getter or variable.
     if (element != null
         && element.isFunction
         // If we found out that the only target is a [:noSuchMethod:],
         // we just ignore it.
-        && element.name == selector.name) {
+        && element.name == node.selector.name) {
       FunctionElement method = element;
 
       if (method.isNative) {
         HInstruction folded = tryInlineNativeMethod(node, method);
         if (folded != null) return folded;
       } else {
         // TODO(ngeoffray): If the method has optional parameters,
         // we should pass the default values.
         FunctionSignature parameters = method.functionSignature;
-        if (parameters.optionalParameterCount == 0
-            || parameters.parameterCount == node.selector.argumentCount) {
+        if (parameters.optionalParameterCount == 0 ||
+            parameters.parameterCount ==
+                node.selector.argumentCount) {
           node.element = element;
         }
       }
     }
     return node;
   }
 
   HInstruction tryInlineNativeMethod(HInvokeDynamicMethod node,
                                      FunctionElement method) {
     // Enable direct calls to a native method only if we don't run in checked
@@ skipping 42 matching lines @@
 
     if (!canInline) return null;
 
     // Strengthen instruction type from annotations to help optimize
     // dependent instructions.
     native.NativeBehavior nativeBehavior =
         native.NativeBehavior.ofMethod(method, compiler);
     TypeMask returnType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
     HInvokeDynamicMethod result =
-        new HInvokeDynamicMethod(node.selector, inputs, returnType);
+        new HInvokeDynamicMethod(node.selector, node.mask, inputs, returnType);
     result.element = method;
     return result;
   }
 
   HInstruction visitBoundsCheck(HBoundsCheck node) {
     HInstruction index = node.index;
     if (index.isInteger(compiler)) return node;
     if (index.isConstant()) {
       HConstant constantInstruction = index;
       assert(!constantInstruction.constant.isInt);
@@ skipping 258 matching lines @@
     ClassWorld classWorld = compiler.world;
     if (checkedType.containsAll(classWorld)) return node;
     HInstruction input = node.checkedInput;
     TypeMask inputType = input.instructionType;
     return inputType.isInMask(checkedType, classWorld) ? input : node;
   }
 
   VariableElement findConcreteFieldForDynamicAccess(HInstruction receiver,
                                                     Selector selector) {
     TypeMask receiverType = receiver.instructionType;
-    return compiler.world.locateSingleField(
-        new TypedSelector(receiverType, selector, compiler.world));
+    return compiler.world.locateSingleField(selector, receiverType);
   }
 
   HInstruction visitFieldGet(HFieldGet node) {
     if (node.isNullCheck) return node;
     var receiver = node.receiver;
     if (node.element == backend.jsIndexableLength) {
       JavaScriptItemCompilationContext context = work.compilationContext;
       if (context.allocatedFixedLists.contains(receiver)) {
         // TODO(ngeoffray): checking if the second input is an integer
         // should not be necessary but it currently makes it easier for
@@ skipping 51 matching lines @@
     }
     return node;
   }
 
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
     HInstruction receiver = node.getDartReceiver(compiler);
-    Element field = findConcreteFieldForDynamicAccess(receiver, node.selector);
+    Element field = findConcreteFieldForDynamicAccess(
+        receiver, node.selector);
     if (field == null) return node;
     return directFieldGet(receiver, field);
   }
 
   HInstruction directFieldGet(HInstruction receiver, Element field) {
     bool isAssignable = !compiler.world.fieldNeverChanges(field);
 
     TypeMask type;
     if (field.enclosingClass.isNative) {
       type = TypeMaskFactory.fromNativeBehavior(
@@ skipping 1481 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }