Split TypedSelector into Selector and TypeMask.

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

 // Copyright (c) 2013, 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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show SynthesizedConstructorElementX,
     ConstructorBodyElementX, FunctionSignatureX;
 import '../io/source_information.dart';
 import '../js_backend/js_backend.dart' show JavaScriptBackend;
 import '../resolution/semantic_visitor.dart';
 import '../resolution/operators.dart' as op;
 import '../tree/tree.dart' as ast;
+import '../types/types.dart' show TypeMask;
 import '../universe/universe.dart' show SelectorKind, CallStructure;
 import 'cps_ir_nodes.dart' as ir;
 import 'cps_ir_builder.dart';
 
 typedef void IrBuilderCallback(Element element, ir.FunctionDefinition irNode);
 
 /// This task provides the interface to build IR nodes from [ast.Node]s, which
 /// is used from the [CpsFunctionCompiler] to generate code.
 ///
 /// This class is mainly there to correctly measure how long building the IR
@@ skipping 129 matching lines @@
   /// For the JS backend, normalizes order of named arguments.
   ///
   /// For the Dart backend, returns [arguments].
   List<ir.Primitive> normalizeDynamicArguments(
       CallStructure callStructure,
       List<ir.Primitive> arguments);
 
   /// Read the value of [field].
   ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src);
 
-  /// Creates a [TypedSelector] variant of [newSelector] using the type of
-  /// [oldSelector], if available.
-  ///
-  /// This is needed to preserve inferred receiver types when creating new
-  /// selectors.
-  Selector useSelectorType(Selector newSelector, Selector oldSelector) {
-    // TODO(asgerf,johnniwinther): This works but it is brittle.
-    //     We should decouple selectors from inferred receiver type masks.
-    // TODO(asgerf): Use this whenever we create a selector for a dynamic call.
-    if (oldSelector is TypedSelector) {
-      return new TypedSelector(oldSelector.mask, newSelector, compiler.world);
-    } else {
-      return newSelector;
-    }
-  }
-
-  /// Like [useSelectorType], except the original typed selector is obtained
-  /// from the [node].
-  Selector useSelectorTypeOfNode(Selector newSelector, ast.Send node) {
-    return useSelectorType(newSelector, elements.getSelector(node));
-  }
-
   ir.FunctionDefinition _makeFunctionBody(FunctionElement element,
                                           ast.FunctionExpression node) {
     FunctionSignature signature = element.functionSignature;
     List<Local> parameters = <Local>[];
     signature.orderedForEachParameter(
         (LocalParameterElement e) => parameters.add(e));
 
     if (element.isFactoryConstructor) {
       // Type arguments are passed in as extra parameters.
       for (DartType typeVariable in element.enclosingClass.typeVariables) {
@@ skipping 126 matching lines @@
     ast.VariableDefinitions variableDeclaration =
         identifier.asVariableDefinitions();
     Element variableElement = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
 
     irBuilder.buildForIn(
         buildExpression: subbuild(node.expression),
         buildVariableDeclaration: subbuild(variableDeclaration),
         variableElement: variableElement,
         variableSelector: selector,
+        variableMask: elements.getTypeMask(identifier),
+        currentMask: elements.getCurrentTypeMask(node),
+        moveNextMask: elements.getMoveNextTypeMask(node),
+        iteratorMask: elements.getIteratorTypeMask(node),
         buildBody: subbuild(node.body),
         target: elements.getTargetDefinition(node),
         closureScope: getClosureScopeForNode(node));
   }
 
   ir.Primitive visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(irBuilder.isOpen);
     if (node.modifiers.isConst) {
       for (ast.SendSet definition in node.definitions.nodes) {
         assert(!definition.arguments.isEmpty);
@@ skipping 227 matching lines @@
   }
 
   @override
   ir.Primitive handleDynamicGet(
       ast.Send node,
       ast.Node receiver,
       Selector selector,
       _) {
     return irBuilder.buildDynamicGet(
         translateReceiver(receiver),
-        selector);
+        selector,
+        elements.getTypeMask(node));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertyGet(
       ast.Send node,
       ast.Node receiver,
       Selector selector,
       _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
-        nested(() => irBuilder.buildDynamicGet(target, selector)));
+        nested(() => irBuilder.buildDynamicGet(
+            target, selector, elements.getTypeMask(node))));
   }
 
   @override
   ir.Primitive visitDynamicTypeLiteralGet(
       ast.Send node,
       ConstantExpression constant,
       _) {
     return buildConstant(constant);
   }
 
@@ skipping 64 matching lines @@
       ast.Send node,
       MethodElement method,
       _) {
     return irBuilder.buildSuperMethodGet(method);
   }
 
   @override
   ir.Primitive visitUnresolvedSuperGet(
       ast.Send node,
       Element element, _) {
-    return buildInstanceNoSuchMethod(elements.getSelector(node), []);
+    return buildInstanceNoSuchMethod(
+        elements.getSelector(node), elements.getTypeMask(node), []);
   }
 
   @override
   ir.Primitive visitThisGet(ast.Identifier node, _) {
     if (irBuilder.state.thisParameter == null) {
       // TODO(asgerf,johnniwinther): Should be in a visitInvalidThis method.
       // 'this' in static context. Just translate to null.
       assert(compiler.compilationFailed);
       return irBuilder.buildNullConstant();
     }
@@ skipping 67 matching lines @@
     ir.Primitive value = visit(expression);
     ir.Primitive check = irBuilder.buildTypeOperator(
         value, type, isTypeTest: true);
     return irBuilder.buildNegation(check);
   }
 
   ir.Primitive translateBinary(ast.Send node,
                                ast.Node left,
                                op.BinaryOperator operator,
                                ast.Node right) {
-    Selector selector = useSelectorTypeOfNode(
-        new Selector.binaryOperator(operator.selectorName),
-        node);
+    Selector selector = new Selector.binaryOperator(operator.selectorName);
     ir.Primitive receiver = visit(left);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(right)];
     arguments = normalizeDynamicArguments(selector.callStructure, arguments);
-    return irBuilder.buildDynamicInvocation(receiver, selector, arguments);
+    return irBuilder.buildDynamicInvocation(
+        receiver, selector, elements.getTypeMask(node), arguments);
   }
 
   @override
   ir.Primitive visitBinary(ast.Send node,
                            ast.Node left,
                            op.BinaryOperator operator,
                            ast.Node right, _) {
     return translateBinary(node, left, operator, right);
   }
 
   @override
   ir.Primitive visitIndex(ast.Send node,
                           ast.Node receiver,
                           ast.Node index, _) {
-    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
+    Selector selector = new Selector.index();
     ir.Primitive target = visit(receiver);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(index)];
     arguments = normalizeDynamicArguments(selector.callStructure, arguments);
-    return irBuilder.buildDynamicInvocation(target, selector, arguments);
+    return irBuilder.buildDynamicInvocation(
+        target, selector, elements.getTypeMask(node), arguments);
   }
 
   ir.Primitive translateSuperBinary(FunctionElement function,
                                     op.BinaryOperator operator,
                                     ast.Node argument) {
     CallStructure callStructure = CallStructure.ONE_ARG;
     List<ir.Primitive> arguments = <ir.Primitive>[visit(argument)];
     arguments = normalizeDynamicArguments(callStructure, arguments);
     return irBuilder.buildSuperMethodInvocation(
         function, callStructure, arguments);
@@ skipping 63 matching lines @@
     return irBuilder.buildNegation(
         translateSuperBinary(function, op.BinaryOperator.NOT_EQ, argument));
   }
 
   @override
   ir.Primitive visitUnary(ast.Send node,
                           op.UnaryOperator operator, ast.Node expression, _) {
     // TODO(johnniwinther): Clean up the creation of selectors.
     Selector selector = operator.selector;
     ir.Primitive receiver = translateReceiver(expression);
-    return irBuilder.buildDynamicInvocation(receiver, selector, const []);
+    return irBuilder.buildDynamicInvocation(
+        receiver, selector, elements.getTypeMask(node), const []);
   }
 
   @override
   ir.Primitive visitSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       FunctionElement function,
       _) {
     return irBuilder.buildSuperMethodInvocation(
         function, CallStructure.NO_ARGS, const []);
@@ skipping 36 matching lines @@
   }
 
   @override
   ir.Primitive handleDynamicInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       Selector selector,
       _) {
     return irBuilder.buildDynamicInvocation(
-        translateReceiver(receiver), selector,
+        translateReceiver(receiver), selector, elements.getTypeMask(node),
         translateDynamicArguments(arguments, selector.callStructure));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertyInvoke(
       ast.Send node,
       ast.Node receiver,
       ast.NodeList arguments,
       Selector selector,
       _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
         nested(() => irBuilder.buildDynamicInvocation(
-            target, selector,
+            target, selector, elements.getTypeMask(node),
             translateDynamicArguments(arguments, selector.callStructure))));
   }
 
   ir.Primitive handleLocalInvoke(
       ast.Send node,
       LocalElement element,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return irBuilder.buildLocalVariableInvocation(element, callStructure,
@@ skipping 111 matching lines @@
   }
 
   @override
   ir.Primitive visitSuperMethodIncompatibleInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     return buildInstanceNoSuchMethod(
         elements.getSelector(node),
+        elements.getTypeMask(node),
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive visitUnresolvedSuperInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
       Selector selector, _) {
     return buildInstanceNoSuchMethod(
         elements.getSelector(node),
+        elements.getTypeMask(node),
         translateDynamicArguments(arguments, selector.callStructure));
   }
 
   @override
   ir.Primitive visitThisInvoke(
       ast.Send node,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     return translateCallInvoke(irBuilder.buildThis(), arguments, callStructure);
@@ skipping 13 matching lines @@
   }
 
   @override
   ir.Primitive visitIndexSet(
        ast.SendSet node,
        ast.Node receiver,
        ast.Node index,
        ast.Node rhs,
        _) {
     return irBuilder.buildDynamicIndexSet(
-        visit(receiver), visit(index), visit(rhs));
+        visit(receiver), elements.getTypeMask(node), visit(index), visit(rhs));
   }
 
   @override
   ir.Primitive visitSuperIndexSet(
       ast.SendSet node,
       FunctionElement function,
       ast.Node index,
       ast.Node rhs,
       _) {
     return irBuilder.buildSuperIndexSet(function, visit(index), visit(rhs));
@@ skipping 19 matching lines @@
         new Selector.binaryOperator(operator.selectorName);
     ir.Primitive rhsValue;
     if (rhs.kind == CompoundKind.ASSIGNMENT) {
       rhsValue = visit(rhs.rhs);
     } else {
       rhsValue = irBuilder.buildIntegerConstant(1);
     }
     List<ir.Primitive> arguments = <ir.Primitive>[rhsValue];
     arguments = normalizeDynamicArguments(
         operatorSelector.callStructure, arguments);
+    // TODO(johnniwinther): Find the type mask for the operation.
     ir.Primitive result =
-        irBuilder.buildDynamicInvocation(value, operatorSelector, arguments);
+        irBuilder.buildDynamicInvocation(
+            value, operatorSelector, null, arguments);
     setValue(result);
     return rhs.kind == CompoundKind.POSTFIX ? value : result;
   }
 
   @override
   ir.Primitive handleDynamicSet(
       ast.SendSet node,
       ast.Node receiver,
       Selector selector,
       ast.Node rhs,
       _) {
     return irBuilder.buildDynamicSet(
         translateReceiver(receiver),
         selector,
+        elements.getTypeMask(node),
         visit(rhs));
   }
 
   @override
   ir.Primitive visitIfNotNullDynamicPropertySet(
       ast.SendSet node,
       ast.Node receiver,
       Selector selector,
       ast.Node rhs,
       _) {
     ir.Primitive target = visit(receiver);
     return irBuilder.buildIfNotNullSend(
         target,
-        nested(() => irBuilder.buildDynamicSet(target, selector, visit(rhs))));
+        nested(() => irBuilder.buildDynamicSet(
+            target, selector, elements.getTypeMask(node), visit(rhs))));
   }
 
   @override
   ir.Primitive handleLocalSet(
       ast.SendSet node,
       LocalElement element,
       ast.Node rhs,
       _) {
     return irBuilder.buildLocalVariableSet(element, visit(rhs));
   }
@@ skipping 51 matching lines @@
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
         getValue: () => buildConstant(constant),
         rhs: rhs,
         setValue: (value) {}); // The binary operator will throw before this.
   }
 
   @override
   ir.Primitive handleDynamicCompounds(
-      ast.Send node,
+      ast.SendSet node,
       ast.Node receiver,
       CompoundRhs rhs,
       Selector getterSelector,
       Selector setterSelector,
       arg) {
     ir.Primitive target = translateReceiver(receiver);
     ir.Primitive helper() {
       return translateCompounds(
-          getValue: () => irBuilder.buildDynamicGet(target, getterSelector),
+          getValue: () => irBuilder.buildDynamicGet(
+              target,
+              getterSelector,
+              elements.getGetterTypeMaskInComplexSendSet(node)),
           rhs: rhs,
           setValue: (ir.Primitive result) {
-            irBuilder.buildDynamicSet(target, setterSelector, result);
+            irBuilder.buildDynamicSet(
+                target, setterSelector, elements.getTypeMask(node), result);
           });
     }
     return node.isConditional
         ? irBuilder.buildIfNotNullSend(target, nested(helper))
         : helper();
   }
 
   ir.Primitive buildLocalNoSuchSetter(Local local, ir.Primitive value) {
     Selector selector = new Selector.setter(local.name, null);
     return buildStaticNoSuchMethod(selector, [value]);
@@ skipping 67 matching lines @@
             case CompoundSetter.SETTER:
               return irBuilder.buildStaticSetterSet(setter, result);
             case CompoundSetter.INVALID:
               // TODO(johnniwinther): Ensure [setter] is non null.
               return buildStaticNoSuchSetter(
                   setter != null ? setter : getter, result);
           }
         });
   }
 
-  ir.Primitive buildSuperNoSuchGetter(Element element) {
+  ir.Primitive buildSuperNoSuchGetter(Element element, TypeMask mask) {
     return buildInstanceNoSuchMethod(
         new Selector.getter(element.name, element.library),
+        mask,
         const <ir.Primitive>[]);
   }
 
-  ir.Primitive buildSuperNoSuchSetter(Element element, ir.Primitive value) {
+  ir.Primitive buildSuperNoSuchSetter(Element element,
+                                      TypeMask mask,
+                                      ir.Primitive value) {
     return buildInstanceNoSuchMethod(
         new Selector.setter(element.name, element.library),
+        mask,
         <ir.Primitive>[value]);
   }
 
   @override
   ir.Primitive handleSuperCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
         getValue: () {
           switch (getterKind) {
             case CompoundGetter.FIELD:
               return irBuilder.buildSuperFieldGet(getter);
             case CompoundGetter.GETTER:
               return irBuilder.buildSuperGetterGet(getter);
             case CompoundGetter.METHOD:
               return irBuilder.buildSuperMethodGet(getter);
             case CompoundGetter.UNRESOLVED:
               // TODO(johnniwinther): Ensure [getter] is not null.
-              return buildSuperNoSuchGetter(getter != null ? getter : setter);
+              return buildSuperNoSuchGetter(
+                  getter != null ? getter : setter,
+                  elements.getGetterTypeMaskInComplexSendSet(node));
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           switch (setterKind) {
             case CompoundSetter.FIELD:
               return irBuilder.buildSuperFieldSet(setter, result);
             case CompoundSetter.SETTER:
               return irBuilder.buildSuperSetterSet(setter, result);
             case CompoundSetter.INVALID:
-              return buildSuperNoSuchSetter(setter, result);
+              return buildSuperNoSuchSetter(
+                  setter, elements.getTypeMask(node), result);
           }
         });
   }
 
   @override
   ir.Primitive handleTypeVariableTypeLiteralCompounds(
       ast.SendSet node,
       TypeVariableElement typeVariable,
       CompoundRhs rhs,
       arg) {
@@ skipping 11 matching lines @@
       CompoundRhs rhs,
       arg) {
     ir.Primitive target = visit(receiver);
     ir.Primitive indexValue = visit(index);
     return translateCompounds(
         getValue: () {
           Selector selector = new Selector.index();
           List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
           arguments =
               normalizeDynamicArguments(selector.callStructure, arguments);
-          return irBuilder.buildDynamicInvocation(target, selector, arguments);
+          return irBuilder.buildDynamicInvocation(
+              target,
+              selector,
+              elements.getGetterTypeMaskInComplexSendSet(node),
+              arguments);
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
-          irBuilder.buildDynamicIndexSet(target, indexValue, result);
+          irBuilder.buildDynamicIndexSet(
+              target,
+              elements.getTypeMask(node),
+              indexValue,
+              result);
         });
   }
 
   @override
   ir.Primitive handleSuperIndexCompounds(
       ast.SendSet node,
       Element indexFunction,
       Element indexSetFunction,
       ast.Node index,
       CompoundRhs rhs,
       arg,
       {bool isGetterValid,
        bool isSetterValid}) {
     ir.Primitive indexValue = visit(index);
     return translateCompounds(
         getValue: () {
           if (isGetterValid) {
             return irBuilder.buildSuperIndex(indexFunction, indexValue);
           } else {
             return buildInstanceNoSuchMethod(
-                new Selector.index(), <ir.Primitive>[indexValue]);
+                new Selector.index(),
+                elements.getGetterTypeMaskInComplexSendSet(node),
+                <ir.Primitive>[indexValue]);
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           if (isSetterValid) {
             irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result);
           } else {
             buildInstanceNoSuchMethod(
-                new Selector.indexSet(), <ir.Primitive>[indexValue, result]);
+                new Selector.indexSet(),
+                elements.getTypeMask(node),
+                <ir.Primitive>[indexValue, result]);
           }
         });
   }
 
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     assert(irBuilder.isOpen);
     ir.Primitive first = visit(node.first);
     ir.Primitive second = visit(node.second);
     return irBuilder.buildStringConcatenation([first, second]);
   }
@@ skipping 22 matching lines @@
     // statements.
     return irBuilder.buildNonTailThrow(visit(node.expression));
   }
 
   ir.Primitive buildStaticNoSuchMethod(
       Selector selector,
       List<ir.Primitive> arguments);
 
   ir.Primitive buildInstanceNoSuchMethod(
       Selector selector,
+      TypeMask mask,
       List<ir.Primitive> arguments);
 
   ir.Primitive buildRuntimeError(String message);
 
   ir.Primitive buildAbstractClassInstantiationError(ClassElement element);
 
   @override
   ir.Primitive errorInvalidAssert(
       ast.Send node,
       ast.NodeList arguments, _) {
@@ skipping 98 matching lines @@
       ast.Node rhs, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node), [visit(rhs)]);
   }
 
   @override
   ir.Primitive visitUnresolvedSuperIndex(
       ast.Send node,
       Element function,
       ast.Node index, _) {
     // Assume the index getter is missing.
-    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
-    return buildInstanceNoSuchMethod(selector, [visit(index)]);
+    return buildInstanceNoSuchMethod(
+        new Selector.index(), elements.getTypeMask(node), [visit(index)]);
   }
 
   @override
   ir.Primitive visitUnresolvedSuperBinary(
       ast.Send node,
       Element element,
       op.BinaryOperator operator,
       ast.Node argument, _) {
     return buildInstanceNoSuchMethod(
         elements.getSelector(node),
+        elements.getTypeMask(node),
         [visit(argument)]);
   }
 
   @override
   ir.Primitive visitUnresolvedSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       Element element, _) {
-    return buildInstanceNoSuchMethod(elements.getSelector(node), []);
+    return buildInstanceNoSuchMethod(
+        elements.getSelector(node), elements.getTypeMask(node), []);
   }
 
   @override
   ir.Primitive errorUndefinedBinaryExpression(
       ast.Send node,
       ast.Node left,
       ast.Operator operator,
       ast.Node right, _) {
     assert(compiler.compilationFailed);
     return irBuilder.buildNullConstant();
@@ skipping 67 matching lines @@
     return buildStaticNoSuchMethod(
         new Selector.setter(field.name, field.library),
         [visit(rhs)]);
   }
 
   @override
   ir.Primitive visitFinalSuperFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
-    Selector selector = useSelectorTypeOfNode(
+    return buildInstanceNoSuchMethod(
         new Selector.setter(field.name, field.library),
-        node);
-    return buildInstanceNoSuchMethod(selector, [visit(rhs)]);
+        elements.getTypeMask(node),
+        [visit(rhs)]);
   }
 
   @override
   ir.Primitive handleImmutableLocalSet(
       ast.SendSet node,
       LocalElement local,
       ast.Node rhs, _) {
     return buildStaticNoSuchMethod(
         new Selector.setter(local.name, null),
         [visit(rhs)]);
@@ skipping 44 matching lines @@
         new Selector(SelectorKind.CALL, name, callStructure),
         args);
   }
 
   @override
   ir.Primitive visitSuperGetterSet(
       ast.SendSet node,
       FunctionElement getter,
       ast.Node rhs,
       _) {
-    Selector selector = useSelectorTypeOfNode(
+    return buildInstanceNoSuchMethod(
         new Selector.setter(getter.name, getter.library),
-        node);
-    return buildInstanceNoSuchMethod(selector, [visit(rhs)]);
+        elements.getTypeMask(node),
+        [visit(rhs)]);
   }
 
   @override
   ir.Primitive visitSuperMethodSet(
       ast.Send node,
       MethodElement method,
       ast.Node rhs,
       _) {
-    Selector selector = useSelectorTypeOfNode(
+    return buildInstanceNoSuchMethod(
         new Selector.setter(method.name, method.library),
-        node);
-    return buildInstanceNoSuchMethod(selector, [visit(rhs)]);
+        elements.getTypeMask(node),
+        [visit(rhs)]);
   }
 
   @override
   ir.Primitive visitSuperSetterGet(
       ast.Send node,
       FunctionElement setter, _) {
-    Selector selector = useSelectorTypeOfNode(
+    return buildInstanceNoSuchMethod(
         new Selector.setter(setter.name, setter.library),
-        node);
-    return buildInstanceNoSuchMethod(selector, []);
+        elements.getTypeMask(node),
+        []);
   }
 
   @override
   ir.Primitive visitSuperSetterInvoke(
       ast.Send node,
       FunctionElement setter,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     List<ir.Primitive> args =
         translateDynamicArguments(arguments, callStructure);
     Name name = new Name(setter.name, setter.library);
-    Selector selector = useSelectorTypeOfNode(
+    return buildInstanceNoSuchMethod(
         new Selector(SelectorKind.CALL, name, callStructure),
-        node);
-    return buildInstanceNoSuchMethod(selector, args);
+        elements.getTypeMask(node),
+        args);
   }
 
   ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
     try {
       return action();
     } catch(e) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
@@ skipping 899 matching lines @@
     ir.Primitive argumentList = irBuilder.buildListLiteral(null, arguments);
     ir.Primitive expectedArgumentNames = irBuilder.buildNullConstant();
     return irBuilder.buildStaticFunctionInvocation(
         thrower,
         new CallStructure.unnamed(4),
         [receiver, name, argumentList, expectedArgumentNames]);
   }
 
   @override
   ir.Primitive buildInstanceNoSuchMethod(Selector selector,
+                                         TypeMask mask,
                                          List<ir.Primitive> arguments) {
     return irBuilder.buildDynamicInvocation(
         irBuilder.buildThis(),
-        useSelectorType(compiler.noSuchMethodSelector, selector),
+        compiler.noSuchMethodSelector,
+        mask,
         [irBuilder.buildInvocationMirror(selector, arguments)]);
   }
 
   @override
   ir.Primitive buildRuntimeError(String message) {
     return irBuilder.buildStaticFunctionInvocation(
         backend.getThrowRuntimeError(),
         new CallStructure.unnamed(1),
         [irBuilder.buildStringConstant(message)]);
   }
@@ skipping 75 matching lines @@
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
 }