dart2js cps_ir: Use interceptors for is-checks (version 2)

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/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 386 matching lines @@
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitConditional(this, arg);
   }
 
   String toString() => 'Conditional(condition=$condition,thenExpression='
                        '$thenExpression,elseExpression=$elseExpression)';
 }
 
 /// An && or || expression. The operator is internally represented as a boolean
 /// [isAnd] to simplify rewriting of logical operators.
+/// Note the the result of && and || is one of the arguments, which might not be
+/// boolean. 'ShortCircuitOperator' might have been a better name.
 class LogicalOperator extends Expression {
   Expression left;
   bool isAnd;
   Expression right;
 
   LogicalOperator(this.left, this.right, this.isAnd);
   LogicalOperator.and(this.left, this.right) : isAnd = true;
   LogicalOperator.or(this.left, this.right) : isAnd = false;
 
   String get operator => isAnd ? '&&' : '||';
@@ skipping 318 matching lines @@
   Expression object;
   Element field;
   Expression value;
 
   SetField(this.object, this.field, this.value);
 
   accept(ExpressionVisitor visitor) => visitor.visitSetField(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitSetField(this, arg);
 }
 
+
+/// Read the type test property from [object]. The value is truthy/fasly rather
+/// than bool. [object] must not be `null`.
+class GetTypeTestProperty extends Expression {
+  Expression object;
+  DartType dartType;
+
+  GetTypeTestProperty(this.object, this.dartType);
+
+  accept(ExpressionVisitor visitor) =>
+      visitor.visitGetTypeTestProperty(this);
+  accept1(ExpressionVisitor1 visitor, arg) =>
+      visitor.visitGetTypeTestProperty(this, arg);
+}
+
+
 /// Read the value of a field, possibly provoking its initializer to evaluate,
 /// or tear off a static method.
 class GetStatic extends Expression {
   Element element;
   SourceInformation sourceInformation;
 
   GetStatic(this.element, this.sourceInformation);
 
   accept(ExpressionVisitor visitor) => visitor.visitGetStatic(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitGetStatic(this, arg);
@@ skipping 213 matching lines @@
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
   E visitFunctionExpression(FunctionExpression node);
   E visitGetField(GetField node);
   E visitSetField(SetField node);
   E visitGetStatic(GetStatic node);
   E visitSetStatic(SetStatic node);
+  E visitGetTypeTestProperty(GetTypeTestProperty node);
   E visitCreateBox(CreateBox node);
   E visitCreateInstance(CreateInstance node);
   E visitReifyRuntimeType(ReifyRuntimeType node);
   E visitReadTypeVariable(ReadTypeVariable node);
   E visitTypeExpression(TypeExpression node);
   E visitCreateInvocationMirror(CreateInvocationMirror node);
   E visitInterceptor(Interceptor node);
   E visitApplyBuiltinOperator(ApplyBuiltinOperator node);
   E visitApplyBuiltinMethod(ApplyBuiltinMethod node);
   E visitForeignExpression(ForeignExpression node);
@@ skipping 17 matching lines @@
   E visitLogicalOperator(LogicalOperator node, A arg);
   E visitNot(Not node, A arg);
   E visitLiteralList(LiteralList node, A arg);
   E visitLiteralMap(LiteralMap node, A arg);
   E visitTypeOperator(TypeOperator node, A arg);
   E visitFunctionExpression(FunctionExpression node, A arg);
   E visitGetField(GetField node, A arg);
   E visitSetField(SetField node, A arg);
   E visitGetStatic(GetStatic node, A arg);
   E visitSetStatic(SetStatic node, A arg);
+  E visitGetTypeTestProperty(GetTypeTestProperty node, A arg);
   E visitCreateBox(CreateBox node, A arg);
   E visitCreateInstance(CreateInstance node, A arg);
   E visitReifyRuntimeType(ReifyRuntimeType node, A arg);
   E visitReadTypeVariable(ReadTypeVariable node, A arg);
   E visitTypeExpression(TypeExpression node, A arg);
   E visitCreateInvocationMirror(CreateInvocationMirror node, A arg);
   E visitInterceptor(Interceptor node, A arg);
   E visitApplyBuiltinOperator(ApplyBuiltinOperator node, A arg);
   E visitApplyBuiltinMethod(ApplyBuiltinMethod node, A arg);
   E visitForeignExpression(ForeignExpression node, A arg);
@@ skipping 174 matching lines @@
     visitExpression(node.value);
   }
 
   visitGetStatic(GetStatic node) {
   }
 
   visitSetStatic(SetStatic node) {
     visitExpression(node.value);
   }
 
+  visitGetTypeTestProperty(GetTypeTestProperty node) {
+    visitExpression(node.object);
+  }
+
   visitCreateBox(CreateBox node) {
   }
 
   visitCreateInstance(CreateInstance node) {
     node.arguments.forEach(visitExpression);
     node.typeInformation.forEach(visitExpression);
   }
 
   visitReifyRuntimeType(ReifyRuntimeType node) {
     visitExpression(node.value);
@@ skipping 225 matching lines @@
     return node;
   }
 
   visitGetStatic(GetStatic node) => node;
 
   visitSetStatic(SetStatic node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
+  visitGetTypeTestProperty(GetTypeTestProperty node) {
+    node.object = visitExpression(node.object);
+    return node;
+  }
+
   visitCreateBox(CreateBox node) => node;
 
   visitCreateInstance(CreateInstance node) {
     _replaceExpressions(node.arguments);
     _replaceExpressions(node.typeInformation);
     return node;
   }
 
   visitReifyRuntimeType(ReifyRuntimeType node) {
     node.value = visitExpression(node.value);
@@ skipping 103 matching lines @@
 
   /// Number of uses of the current fallthrough target.
   int get useCount => _stack.last.useCount;
 
   /// Indicate that a statement will fall through to the current fallthrough
   /// target.
   void use() {
     ++_stack.last.useCount;
   }
 }