Revert "dart2js cps: 'is' checks on types with type arguments."

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, GenericType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 312 matching lines @@
   final List<LiteralMapEntry> entries;
 
   LiteralMap(this.type, this.entries);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralMap(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitLiteralMap(this, arg);
   }
 }
 
+/// Given the interceptor for a value, test the value against a type.
 class TypeOperator extends Expression {
-  Expression value;
+  Expression receiver;
   final DartType type;
-  final List<Expression> typeArguments;
   final bool isTypeTest;
 
-  TypeOperator(this.value, this.type, this.typeArguments,
-               {bool this.isTypeTest});
+  TypeOperator(this.receiver, this.type, {bool this.isTypeTest});
 
   accept(ExpressionVisitor visitor) => visitor.visitTypeOperator(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitTypeOperator(this, arg);
   }
 
   String get operator => isTypeTest ? 'is' : 'as';
 }
 
 /// A conditional expression.
@@ skipping 800 matching lines @@
   }
 
   visitLiteralMap(LiteralMap node) {
     node.entries.forEach((LiteralMapEntry entry) {
       visitExpression(entry.key);
       visitExpression(entry.value);
     });
   }
 
   visitTypeOperator(TypeOperator node) {
-    visitExpression(node.value);
-    node.typeArguments.forEach(visitExpression);
+    visitExpression(node.receiver);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     visitInnerFunction(node.definition);
   }
 
   visitLabeledStatement(LabeledStatement node) {
     visitStatement(node.body);
     visitStatement(node.next);
   }
@@ skipping 171 matching lines @@
 
   visitLiteralMap(LiteralMap node) {
     node.entries.forEach((LiteralMapEntry entry) {
       entry.key = visitExpression(entry.key);
       entry.value = visitExpression(entry.value);
     });
     return node;
   }
 
   visitTypeOperator(TypeOperator node) {
-    node.value = visitExpression(node.value);
-    _replaceExpressions(node.typeArguments);
+    node.receiver = visitExpression(node.receiver);
     return node;
   }
 
   visitFunctionExpression(FunctionExpression node) {
     visitInnerFunction(node.definition);
     return node;
   }
 
   visitLabeledStatement(LabeledStatement node) {
     node.body = visitStatement(node.body);
@@ skipping 92 matching lines @@
   visitTypeExpression(TypeExpression node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 }