Revert "Split TypedSelector into Selector and TypeMask."

pkg/compiler/lib/src/ssa/builder.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;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 1279 matching lines @@
     }
     return compiledArguments;
   }
 
   /**
    * Try to inline [element] within the currect context of the builder. The
    * insertion point is the state of the builder.
    */
   bool tryInlineMethod(Element element,
                        Selector selector,
-                       TypeMask mask,
                        List<HInstruction> providedArguments,
                        ast.Node currentNode,
                        {InterfaceType instanceType}) {
     // TODO(johnniwinther): Register this on the [registry]. Currently the
     // [CodegenRegistry] calls the enqueuer, but [element] should _not_ be
     // enqueued.
     backend.registerStaticUse(element, compiler.enqueuer.codegen);
 
     // Ensure that [element] is an implementation element.
     element = element.implementation;
@@ skipping 11 matching lines @@
 
     bool meetsHardConstraints() {
       if (compiler.disableInlining) return false;
 
       assert(invariant(
           currentNode != null ? currentNode : element,
           selector != null ||
           Elements.isStaticOrTopLevel(element) ||
           element.isGenerativeConstructorBody,
           message: "Missing selector for inlining of $element."));
-      if (selector != null) {
-        if (!selector.applies(function, compiler.world)) return false;
-        if (mask != null && !mask.canHit(function, selector, compiler.world)) {
-          return false;
-        }
+      if (selector != null && !selector.applies(function, compiler.world)) {
+        return false;
       }
 
       // Don't inline operator== methods if the parameter can be null.
       if (element.name == '==') {
         if (element.enclosingClass != compiler.objectClass
             && providedArguments[1].canBeNull()) {
           return false;
         }
       }
 
@@ skipping 98 matching lines @@
       } else {
         backend.inlineCache.markAsNonInlinable(element, insideLoop: insideLoop);
       }
       return canInline;
     }
 
     void doInlining() {
       // Add an explicit null check on the receiver before doing the
       // inlining. We use [element] to get the same name in the
       // NoSuchMethodError message as if we had called it.
-      if (element.isInstanceMember &&
-          !element.isGenerativeConstructorBody &&
-          (mask == null || mask.isNullable)) {
+      if (element.isInstanceMember
+          && !element.isGenerativeConstructorBody
+          && (selector.mask == null || selector.mask.isNullable)) {
         addWithPosition(
             new HFieldGet(null, providedArguments[0], backend.dynamicType,
                           isAssignable: false),
             currentNode);
       }
       List<HInstruction> compiledArguments = completeSendArgumentsList(
           function, selector, providedArguments, currentNode);
       enterInlinedMethod(
           function, currentNode, compiledArguments, instanceType: instanceType);
       inlinedFrom(function, () {
@@ skipping 826 matching lines @@
         // parameters of the generative constructor body.
         currentClass.typeVariables.forEach((TypeVariableType argument) {
           // TODO(johnniwinther): Substitute [argument] with
           // `localsHandler.substInContext(argument)`.
           bodyCallInputs.add(localsHandler.readLocal(
               localsHandler.getTypeVariableAsLocal(argument)));
         });
       }
 
       if (!isNativeUpgradeFactory && // TODO(13836): Fix inlining.
-          tryInlineMethod(body, null, null, bodyCallInputs, function)) {
+          tryInlineMethod(body, null, bodyCallInputs, function)) {
         pop();
       } else {
         HInvokeConstructorBody invoke = new HInvokeConstructorBody(
             body.declaration, bodyCallInputs, backend.nonNullType);
         invoke.sideEffects =
             compiler.world.getSideEffectsOfElement(constructor);
         add(invoke);
       }
     }
     if (inliningStack.isEmpty) {
@@ skipping 133 matching lines @@
           original, typeVariable);
     } else if (type.isFunctionType) {
       String name = kind == HTypeConversion.CAST_TYPE_CHECK
           ? '_asCheck' : '_assertCheck';
 
       List<HInstruction> arguments =
           <HInstruction>[buildFunctionType(type), original];
       pushInvokeDynamic(
           null,
           new Selector.call(name, backend.jsHelperLibrary, 1),
-          null,
           arguments);
 
       return new HTypeConversion(type, kind, original.instructionType, pop());
     } else {
       return original.convertType(compiler, type, kind);
     }
   }
 
   HInstruction _trustType(HInstruction original, DartType type) {
     assert(compiler.trustTypeAnnotations);
@@ skipping 720 matching lines @@
     if (operand is HConstant) {
       UnaryOperation operation = constantSystem.lookupUnary(operator);
       HConstant constant = operand;
       ConstantValue folded = operation.fold(constant.constant);
       if (folded != null) {
         stack.add(graph.addConstant(folded, compiler));
         return;
       }
     }
 
-    pushInvokeDynamic(
-        node,
-        elements.getSelector(node),
-        elements.getTypeMask(node),
-        [operand]);
+    pushInvokeDynamic(node, elements.getSelector(node), [operand]);
   }
 
   @override
   void visitBinary(ast.Send node,
                    ast.Node left,
                    BinaryOperator operator,
                    ast.Node right, _) {
     handleBinary(node, left, right);
   }
 
@@ skipping 11 matching lines @@
   void visitNotEquals(ast.Send node, ast.Node left, ast.Node right, _) {
     handleBinary(node, left, right);
     pushWithPosition(new HNot(popBoolified(), backend.boolType), node.selector);
   }
 
   void handleBinary(ast.Send node, ast.Node left, ast.Node right) {
     visitBinarySend(
         visitAndPop(left),
         visitAndPop(right),
         elements.getSelector(node),
-        elements.getTypeMask(node),
         node,
         location: node.selector);
   }
 
   /// TODO(johnniwinther): Merge [visitBinarySend] with [handleBinary] and
   /// remove use of [location] for source information.
   void visitBinarySend(HInstruction left,
                        HInstruction right,
                        Selector selector,
-                       TypeMask mask,
                        ast.Send send,
                        {ast.Node location}) {
-    pushInvokeDynamic(send, selector, mask, [left, right], location: location);
+    pushInvokeDynamic(send, selector, [left, right], location: location);
   }
 
   HInstruction generateInstanceSendReceiver(ast.Send send) {
     assert(Elements.isInstanceSend(send, elements));
     if (send.receiver == null) {
       return localsHandler.readThis();
     }
     visit(send.receiver);
     return pop();
   }
 
   String noSuchMethodTargetSymbolString(Element error, [String prefix]) {
     String result = error.name;
     if (prefix == "set") return "$result=";
     return result;
   }
 
   /**
    * Returns a set of interceptor classes that contain the given
    * [selector].
    */
-  void generateInstanceGetterWithCompiledReceiver(
-      ast.Send send,
-      Selector selector,
-      TypeMask mask,
-      HInstruction receiver) {
+  void generateInstanceGetterWithCompiledReceiver(ast.Send send,
+                                                  Selector selector,
+                                                  HInstruction receiver) {
     assert(Elements.isInstanceSend(send, elements));
     assert(selector.isGetter);
-    pushInvokeDynamic(send, selector, mask, [receiver]);
+    pushInvokeDynamic(send, selector, [receiver]);
   }
 
   /// Inserts a call to checkDeferredIsLoaded for [prefixElement].
   /// If [prefixElement] is [null] ndo nothing.
   void generateIsDeferredLoadedCheckIfNeeded(PrefixElement prefixElement,
                                              ast.Node location) {
     if (prefixElement == null) return;
     String loadId =
         compiler.deferredLoadTask.importDeferName[prefixElement.deferredImport];
     HInstruction loadIdConstant = addConstantString(loadId);
@@ skipping 97 matching lines @@
     } else {
       generateIsDeferredLoadedCheckOfSend(node);
       pushInvokeStatic(node, getter, <HInstruction>[]);
     }
   }
 
   /// Generate a dynamic getter invocation.
   void generateDynamicGet(ast.Send node) {
     HInstruction receiver = generateInstanceSendReceiver(node);
     generateInstanceGetterWithCompiledReceiver(
-        node, elements.getSelector(node), elements.getTypeMask(node), receiver);
+        node, elements.getSelector(node), receiver);
   }
 
   /// Generate a closurization of the static or top level [function].
   void generateStaticFunctionGet(ast.Send node, MethodElement function) {
     generateIsDeferredLoadedCheckOfSend(node);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     push(new HStatic(function.declaration, backend.nonNullType));
     // TODO(ahe): This should be registered in codegen.
     registry.registerGetOfStaticFunction(function.declaration);
@@ skipping 26 matching lines @@
     // we will be able to later compress it as:
     //   t1 || t1.x
     HInstruction expression;
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleConditional(
         () {
           expression = visitAndPop(receiver);
           pushCheckNull(expression);
         },
         () => stack.add(expression),
-        () {
-          generateInstanceGetterWithCompiledReceiver(
-              node,
-              elements.getSelector(node),
-              elements.getTypeMask(node),
-              expression);
-        });
+        () => generateInstanceGetterWithCompiledReceiver(
+            node, elements.getSelector(node), expression));
   }
 
   /// Pushes a boolean checking [expression] against null.
   pushCheckNull(HInstruction expression) {
     push(new HIdentity(expression, graph.addConstantNull(compiler),
           null, backend.boolType));
   }
 
   @override
   void visitLocalVariableGet(ast.Send node, LocalVariableElement variable, _) {
@@ skipping 63 matching lines @@
       ast.Send node,
       FunctionElement getter,
       _) {
     generateStaticGetterGet(node, getter);
   }
 
   void generateInstanceSetterWithCompiledReceiver(ast.Send send,
                                                   HInstruction receiver,
                                                   HInstruction value,
                                                   {Selector selector,
-                                                   TypeMask mask,
                                                    ast.Node location}) {
     assert(send == null || Elements.isInstanceSend(send, elements));
     if (selector == null) {
       assert(send != null);
       selector = elements.getSelector(send);
-      if (mask == null) {
-        mask = elements.getTypeMask(send);
-      }
     }
     if (location == null) {
       assert(send != null);
       location = send;
     }
     assert(selector.isSetter);
-    pushInvokeDynamic(location, selector, mask, [receiver, value]);
+    pushInvokeDynamic(location, selector, [receiver, value]);
     pop();
     stack.add(value);
   }
 
   void generateNonInstanceSetter(ast.SendSet send,
                                  Element element,
                                  HInstruction value,
                                  {ast.Node location}) {
     assert(send == null || !Elements.isInstanceSend(send, elements));
     if (location == null) {
@@ skipping 114 matching lines @@
     push(new HNot(instruction, backend.boolType));
   }
 
   HInstruction buildIsNode(ast.Node node,
                            DartType type,
                            HInstruction expression) {
     type = localsHandler.substInContext(type).unalias(compiler);
     if (type.isFunctionType) {
       List arguments = [buildFunctionType(type), expression];
       pushInvokeDynamic(
-          node,
-          new Selector.call('_isTest', backend.jsHelperLibrary, 1),
-          null,
+          node, new Selector.call('_isTest', backend.jsHelperLibrary, 1),
           arguments);
       return new HIs.compound(type, expression, pop(), backend.boolType);
     } else if (type.isTypeVariable) {
       HInstruction runtimeType = addTypeVariableReference(type);
       Element helper = backend.getCheckSubtypeOfRuntimeType();
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
       pushInvokeStatic(null, helper, inputs, typeMask: backend.boolType);
       HInstruction call = pop();
       return new HIs.variable(type, expression, call, backend.boolType);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
@@ skipping 101 matching lines @@
   }
 
   /// Generate a dynamic method, getter or setter invocation.
   void generateDynamicSend(ast.Send node) {
     HInstruction receiver = generateInstanceSendReceiver(node);
     _generateDynamicSend(node, receiver);
   }
 
   void _generateDynamicSend(ast.Send node, HInstruction receiver) {
     Selector selector = elements.getSelector(node);
-    TypeMask mask = elements.getTypeMask(node);
 
     List<HInstruction> inputs = <HInstruction>[];
     inputs.add(receiver);
     addDynamicSendArgumentsToList(node, inputs);
 
-    pushInvokeDynamic(node, selector, mask, inputs);
+    pushInvokeDynamic(node, selector, inputs);
     if (selector.isSetter || selector.isIndexSet) {
       pop();
       stack.add(inputs.last);
     }
   }
 
   @override
   visitDynamicPropertyInvoke(
       ast.Send node,
       ast.Node receiver,
@@ skipping 343 matching lines @@
         MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     stack.add(graph.addConstantNull(compiler));
   }
 
   void handleForeignJsCallInIsolate(ast.Send node) {
     Link<ast.Node> link = node.arguments;
     if (!compiler.hasIsolateSupport) {
       // If the isolate library is not used, we just invoke the
       // closure.
       visit(link.tail.head);
-      push(new HInvokeClosure(new Selector.callClosure(0),
+      Selector selector = new Selector.callClosure(0);
+      push(new HInvokeClosure(selector,
                               <HInstruction>[pop()],
                               backend.dynamicType));
     } else {
       // Call a helper method from the isolate library.
       Element element = backend.isolateHelperLibrary.find('_callInIsolate');
       if (element == null) {
         compiler.internalError(node,
             'Isolate library and compiler mismatch.');
       }
       List<HInstruction> inputs = <HInstruction>[];
@@ skipping 121 matching lines @@
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
     Element element = cls.lookupSuperMember(Compiler.NO_SUCH_METHOD);
     if (compiler.enabledInvokeOn
         && element.enclosingElement.declaration != compiler.objectClass) {
       // Register the call as dynamic if [noSuchMethod] on the super
       // class is _not_ the default implementation from [Object], in
       // case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
-      registry.registerSelectorUse(selector);
+      registry.registerSelectorUse(selector.asUntyped);
     }
     String publicName = name;
     if (selector.isSetter) publicName += '=';
 
     ConstantValue nameConstant = constantSystem.createString(
         new ast.DartString.literal(publicName));
 
     String internalName = backend.namer.invocationName(selector);
     ConstantValue internalNameConstant =
         constantSystem.createString(new ast.DartString.literal(internalName));
@@ skipping 995 matching lines @@
     // in if it is not used (e.g., in a try/catch).
     HInstruction target = pop();
     generateCallInvoke(node, target);
   }
 
   /// Generate a '.call' invocation on [target].
   void generateCallInvoke(ast.Send node, HInstruction target) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> inputs = <HInstruction>[target];
     addDynamicSendArgumentsToList(node, inputs);
+    Selector closureSelector = new Selector.callClosureFrom(selector);
     pushWithPosition(
-        new HInvokeClosure(
-            new Selector.callClosureFrom(selector),
-            inputs, backend.dynamicType),
-        node);
+        new HInvokeClosure(closureSelector, inputs, backend.dynamicType), node);
   }
 
   visitGetterSend(ast.Send node) {
     internalError(node, "Unexpected visitGetterSend");
   }
 
   // TODO(antonm): migrate rest of SsaFromAstMixin to internalError.
   internalError(Spannable node, String reason) {
     compiler.internalError(node, reason);
   }
@@ skipping 108 matching lines @@
         String nameString = stringConstant.toDartString().slowToString();
         registry.registerConstSymbol(nameString);
       }
     } else {
       handleNewSend(node);
     }
   }
 
   void pushInvokeDynamic(ast.Node node,
                          Selector selector,
-                         TypeMask mask,
                          List<HInstruction> arguments,
                          {ast.Node location}) {
     if (location == null) location = node;
 
     // We prefer to not inline certain operations on indexables,
     // because the constant folder will handle them better and turn
     // them into simpler instructions that allow further
     // optimizations.
     bool isOptimizableOperationOnIndexable(Selector selector, Element element) {
       bool isLength = selector.isGetter
@@ skipping 20 matching lines @@
       if (selector.isIndex) return true;
       if (selector.isIndexSet) return true;
       if (element == backend.jsArrayAdd
           || element == backend.jsArrayRemoveLast
           || element == backend.jsStringSplit) {
         return true;
       }
       return false;
     }
 
-    Element element = compiler.world.locateSingleElement(selector, mask);
-    if (element != null &&
-        !element.isField &&
-        !(element.isGetter && selector.isCall) &&
-        !(element.isFunction && selector.isGetter) &&
-        !isOptimizableOperation(selector, element)) {
-      if (tryInlineMethod(element, selector, mask, arguments, node)) {
+    Element element = compiler.world.locateSingleElement(selector);
+    if (element != null
+        && !element.isField
+        && !(element.isGetter && selector.isCall)
+        && !(element.isFunction && selector.isGetter)
+        && !isOptimizableOperation(selector, element)) {
+      if (tryInlineMethod(element, selector, arguments, node)) {
         return;
       }
     }
 
     HInstruction receiver = arguments[0];
     List<HInstruction> inputs = <HInstruction>[];
     bool isIntercepted = backend.isInterceptedSelector(selector);
     if (isIntercepted) {
       inputs.add(invokeInterceptor(receiver));
     }
     inputs.addAll(arguments);
-    TypeMask type =
-        TypeMaskFactory.inferredTypeForSelector(selector, mask, compiler);
+    TypeMask type = TypeMaskFactory.inferredTypeForSelector(selector, compiler);
     if (selector.isGetter) {
       pushWithPosition(
-          new HInvokeDynamicGetter(selector, mask, null, inputs, type),
+          new HInvokeDynamicGetter(selector, null, inputs, type),
           location);
     } else if (selector.isSetter) {
       pushWithPosition(
-          new HInvokeDynamicSetter(selector, mask, null, inputs, type),
+          new HInvokeDynamicSetter(selector, null, inputs, type),
           location);
     } else {
       pushWithPosition(
-          new HInvokeDynamicMethod(selector, mask, inputs, type, isIntercepted),
+          new HInvokeDynamicMethod(selector, inputs, type, isIntercepted),
           location);
     }
   }
 
   void pushInvokeStatic(ast.Node location,
                         Element element,
                         List<HInstruction> arguments,
                         {TypeMask typeMask,
                          InterfaceType instanceType}) {
-    if (tryInlineMethod(element, null, null, arguments, location,
+    if (tryInlineMethod(element, null, arguments, location,
                         instanceType: instanceType)) {
       return;
     }
 
     if (typeMask == null) {
       typeMask =
           TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
     }
     bool targetCanThrow = !compiler.world.getCannotThrow(element);
     // TODO(5346): Try to avoid the need for calling [declaration] before
@@ skipping 34 matching lines @@
     } else {
       type = TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
     }
     HInstruction instruction = new HInvokeSuper(
         element,
         currentNonClosureClass,
         selector,
         inputs,
         type,
         isSetter: selector.isSetter || selector.isIndexSet);
-    instruction.sideEffects =
-        compiler.world.getSideEffectsOfSelector(selector, null);
+    instruction.sideEffects = compiler.world.getSideEffectsOfSelector(selector);
     return instruction;
   }
 
   void handleComplexOperatorSend(ast.SendSet node,
                                  HInstruction receiver,
                                  Link<ast.Node> arguments) {
     HInstruction rhs;
     if (node.isPrefix || node.isPostfix) {
       rhs = graph.addConstantInt(1, compiler);
     } else {
       visit(arguments.head);
       assert(arguments.tail.isEmpty);
       rhs = pop();
     }
     visitBinarySend(receiver, rhs,
                     elements.getOperatorSelectorInComplexSendSet(node),
-                    elements.getOperatorTypeMaskInComplexSendSet(node),
                     node,
                     location: node.assignmentOperator);
   }
 
   void handleSuperSendSet(ast.SendSet node) {
     Element element = elements[node];
     List<HInstruction> setterInputs = <HInstruction>[];
     void generateSuperSendSet() {
       Selector setterSelector = elements.getSelector(node);
       if (Elements.isUnresolved(element)
@@ skipping 77 matching lines @@
       HInstruction index;
       if (node.isIndex) {
         visit(arguments.head);
         arguments = arguments.tail;
         index = pop();
       }
 
       pushInvokeDynamic(
           node,
           elements.getGetterSelectorInComplexSendSet(node),
-          elements.getGetterTypeMaskInComplexSendSet(node),
           [receiver, index]);
       HInstruction getterInstruction = pop();
       if (node.isIfNullAssignment) {
         // Compile x[i] ??= e as:
         //   t1 = x[i]
         //   if (t1 == null)
         //      t1 = x[i] = e;
         //   result = t1
         SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
         brancher.handleIfNull(() => stack.add(getterInstruction),
             () {
               visit(arguments.head);
               HInstruction value = pop();
               pushInvokeDynamic(
-                  node,
-                  elements.getSelector(node),
-                  elements.getTypeMask(node),
-                  [receiver, index, value]);
+                  node, elements.getSelector(node), [receiver, index, value]);
               pop();
               stack.add(value);
             });
       } else {
         handleComplexOperatorSend(node, getterInstruction, arguments);
         HInstruction value = pop();
         pushInvokeDynamic(
-            node,
-            elements.getSelector(node),
-            elements.getTypeMask(node),
-            [receiver, index, value]);
+            node, elements.getSelector(node), [receiver, index, value]);
         pop();
         if (node.isPostfix) {
           stack.add(getterInstruction);
         } else {
           stack.add(value);
         }
       }
     }
   }
 
@@ skipping 266 matching lines @@
         generateThrowNoSuchMethod(node, selector.source,
                                   argumentNodes: node.arguments);
       }
       return;
     }
 
     if (Elements.isInstanceSend(node, elements)) {
       void generateAssignment(HInstruction receiver) {
         // desugars `e.x op= e2` to `e.x = e.x op e2`
         generateInstanceGetterWithCompiledReceiver(
-            node,
-            elements.getGetterSelectorInComplexSendSet(node),
-            elements.getGetterTypeMaskInComplexSendSet(node),
-            receiver);
+            node, elements.getGetterSelectorInComplexSendSet(node), receiver);
         HInstruction getterInstruction = pop();
         if (node.isIfNullAssignment) {
           SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
           brancher.handleIfNull(() => stack.add(getterInstruction),
               () {
                 visit(node.arguments.head);
                 generateInstanceSetterWithCompiledReceiver(
                     node, receiver, pop());
               });
         } else {
@@ skipping 430 matching lines @@
     HInstruction expression = pop();
     pushInvokeStatic(node,
                      backend.getStreamIteratorConstructor(),
                      [expression, graph.addConstantNull(compiler)]);
     streamIterator = pop();
 
     void buildInitializer() {}
 
     HInstruction buildCondition() {
       Selector selector = elements.getMoveNextSelector(node);
-      TypeMask mask = elements.getMoveNextTypeMask(node);
-      pushInvokeDynamic(node, selector, mask, [streamIterator]);
+      pushInvokeDynamic(node, selector, [streamIterator]);
       HInstruction future = pop();
       push(new HAwait(future, new TypeMask.subclass(compiler.objectClass,
                                                     compiler.world)));
       return popBoolified();
     }
     void buildBody() {
       Selector call = elements.getCurrentSelector(node);
-      TypeMask callMask = elements.getCurrentTypeMask(node);
-      pushInvokeDynamic(node, call, callMask, [streamIterator]);
+      pushInvokeDynamic(node, call, [streamIterator]);
 
       ast.Node identifier = node.declaredIdentifier;
       Element variable = elements.getForInVariable(node);
       Selector selector = elements.getSelector(identifier);
-      TypeMask mask = elements.getTypeMask(identifier);
 
       HInstruction value = pop();
       if (identifier.asSend() != null
           && Elements.isInstanceSend(identifier, elements)) {
         HInstruction receiver = generateInstanceSendReceiver(identifier);
         assert(receiver != null);
         generateInstanceSetterWithCompiledReceiver(
             null,
             receiver,
             value,
             selector: selector,
-            mask: mask,
             location: identifier);
       } else {
         generateNonInstanceSetter(
             null, variable, value, location: identifier);
       }
       pop(); // Pop the value pushed by the setter call.
 
       visit(node.body);
     }
 
     void buildUpdate() {};
 
     buildProtectedByFinally(() {
       handleLoop(node,
                  buildInitializer,
                  buildCondition,
                  buildUpdate,
                  buildBody);
     }, () {
-      pushInvokeDynamic(node,
-          new Selector.call("cancel", null, 0),
-          null,
+      pushInvokeDynamic(node, new Selector.call("cancel", null, 0),
           [streamIterator]);
       push(new HAwait(pop(), new TypeMask.subclass(compiler.objectClass,
           compiler.world)));
       pop();
     });
   }
 
   visitSyncForIn(ast.SyncForIn node) {
     // The 'get iterator' selector for this node has the inferred receiver type.
     // If the receiver supports JavaScript indexing we generate an indexing loop
     // instead of allocating an iterator object.
 
     // This scheme recognizes for-in on direct lists.  It does not recognize all
     // uses of ArrayIterator.  They still occur when the receiver is an Iterable
     // with a `get iterator` method that delegate to another Iterable and the
     // method is inlined.  We would require full scalar replacement in that
     // case.
 
     Selector selector = elements.getIteratorSelector(node);
-    TypeMask mask = elements.getIteratorTypeMask(node);
+    TypeMask mask = selector.mask;
 
     ClassWorld classWorld = compiler.world;
     if (mask != null && mask.satisfies(backend.jsIndexableClass, classWorld)) {
       return buildSyncForInIndexable(node, mask);
     }
     buildSyncForInIterator(node);
   }
 
   buildSyncForInIterator(ast.SyncForIn node) {
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator;
     //   while ($iter.moveNext()) {
     //     <declaredIdentifier> = $iter.current;
     //     <body>
     //   }
 
     // The iterator is shared between initializer, condition and body.
     HInstruction iterator;
 
     void buildInitializer() {
       Selector selector = elements.getIteratorSelector(node);
-      TypeMask mask = elements.getIteratorTypeMask(node);
       visit(node.expression);
       HInstruction receiver = pop();
-      pushInvokeDynamic(node, selector, mask, [receiver]);
+      pushInvokeDynamic(node, selector, [receiver]);
       iterator = pop();
     }
 
     HInstruction buildCondition() {
       Selector selector = elements.getMoveNextSelector(node);
-      TypeMask mask = elements.getMoveNextTypeMask(node);
-      pushInvokeDynamic(node, selector, mask, [iterator]);
+      pushInvokeDynamic(node, selector, [iterator]);
       return popBoolified();
     }
 
     void buildBody() {
       Selector call = elements.getCurrentSelector(node);
-      TypeMask mask = elements.getCurrentTypeMask(node);
-      pushInvokeDynamic(node, call, mask, [iterator]);
+      pushInvokeDynamic(node, call, [iterator]);
       buildAssignLoopVariable(node, pop());
       visit(node.body);
     }
 
     handleLoop(node, buildInitializer, buildCondition, () {}, buildBody);
   }
 
   buildAssignLoopVariable(ast.ForIn node, HInstruction value) {
     ast.Node identifier = node.declaredIdentifier;
     Element variable = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
-    TypeMask mask = elements.getTypeMask(identifier);
 
     if (identifier.asSend() != null &&
         Elements.isInstanceSend(identifier, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(identifier);
       assert(receiver != null);
       generateInstanceSetterWithCompiledReceiver(
           null,
           receiver,
           value,
           selector: selector,
-          mask: mask,
           location: identifier);
     } else {
       generateNonInstanceSetter(null, variable, value, location: identifier);
     }
     pop();  // Discard the value pushed by the setter call.
   }
 
   buildSyncForInIndexable(ast.ForIn node, TypeMask arrayType) {
     // Generate a structure equivalent to:
     //
@@ skipping 59 matching lines @@
       // inserted the ConcurrentModificationError check as part of the
       // condition.  It is not necessary on the first iteration since there is
       // no code between calls to `get iterator` and `moveNext`, so the test is
       // moved to the loop update.
 
       // Find a type for the element. Use the element type of the indexer of the
       // array, as this is stronger than the iterator's `get current` type, for
       // example, `get current` includes null.
       // TODO(sra): The element type of a container type mask might be better.
       Selector selector = new Selector.index();
-      TypeMask type = TypeMaskFactory.inferredTypeForSelector(
-          selector, arrayType, compiler);
+      Selector refined = new TypedSelector(arrayType, selector, compiler.world);
+      TypeMask type =
+          TypeMaskFactory.inferredTypeForSelector(refined, compiler);
 
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction value = new HIndex(array, index, null, type);
       add(value);
 
       buildAssignLoopVariable(node, value);
       visit(node.body);
     }
 
     void buildUpdate() {
@@ skipping 896 matching lines @@
     //      conversions.
     //   2. The value can be primitive, because the library stringifier has
     //      fast-path code for most primitives.
     if (expression.canBePrimitive(compiler)) {
       append(stringify(node, expression));
       return;
     }
 
     // If the `toString` method is guaranteed to return a string we can call it
     // directly.
-    Selector selector = new Selector.call('toString', null, 0);
-    TypeMask type = TypeMaskFactory.inferredTypeForSelector(
-        selector, expression.instructionType, compiler);
+    Selector selector =
+        new TypedSelector(expression.instructionType,
+            new Selector.call('toString', null, 0), compiler.world);
+    TypeMask type = TypeMaskFactory.inferredTypeForSelector(selector, compiler);
     if (type.containsOnlyString(compiler.world)) {
-      builder.pushInvokeDynamic(
-          node, selector, expression.instructionType, <HInstruction>[expression]);
+      builder.pushInvokeDynamic(node, selector, <HInstruction>[expression]);
       append(builder.pop());
       return;
     }
 
     append(stringify(node, expression));
   }
 
   void visitStringInterpolation(ast.StringInterpolation node) {
     node.visitChildren(this);
   }
@@ skipping 525 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }