Revert "Split TypedSelector into Selector and TypeMask."

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.dart

 // Copyright (c) 2014, 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 tree_ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
-import '../types/types.dart' show TypeMask;
 import '../universe/universe.dart' show Selector;
 
 import '../cps_ir/builtin_operator.dart';
 export '../cps_ir/builtin_operator.dart';
 
 // The Tree language is the target of translation out of the CPS-based IR.
 //
 // The translation from CPS to Dart consists of several stages.  Among the
 // stages are translation to direct style, translation out of SSA, eliminating
 // unnecessary names, recognizing high-level control constructs.  Combining
@@ skipping 131 matching lines @@
                                            [Statement next]) {
     return new ExpressionStatement(new Assign(variable, value), next);
   }
 }
 
 /**
  * Common interface for invocations with arguments.
  */
 abstract class Invoke {
   List<Expression> get arguments;
+  Selector get selector;
 }
 
 /**
  * A call to a static function or getter/setter to a static field.
  *
  * In contrast to the CPS-based IR, the arguments can be arbitrary expressions.
  */
 class InvokeStatic extends Expression implements Invoke {
   final Entity target;
   final List<Expression> arguments;
@@ skipping 19 matching lines @@
 
 /**
  * A call to a method, operator, getter, setter or index getter/setter.
  *
  * If [receiver] is `null`, an error is thrown before the arguments are
  * evaluated. This corresponds to the JS evaluation order.
  */
 class InvokeMethod extends Expression implements Invoke {
   Expression receiver;
   final Selector selector;
-  final TypeMask mask;
   final List<Expression> arguments;
 
   /// If true, it is known that the receiver cannot be `null`.
   bool receiverIsNotNull = false;
 
-  InvokeMethod(this.receiver, this.selector, this.mask, this.arguments) {
+  InvokeMethod(this.receiver, this.selector, this.arguments) {
     assert(receiver != null);
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeMethod(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitInvokeMethod(this, arg);
   }
 }
 
 /// Invoke [target] on [receiver], bypassing ordinary dispatch semantics.
@@ skipping 1036 matching lines @@
 
   visitUnreachable(Unreachable node) {
     return node;
   }
 
   visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 }