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

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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_nodes;
 
 import 'dart:collection';
 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 571 matching lines @@
 ///
 /// Returns `true` if [value] is an instance of [type].
 ///
 /// [type] must not be the [Object], `dynamic` or [Null] types (though it might
 /// be a type variable containing one of these types). This design is chosen
 /// to simplify code generation for type tests.
 class TypeTest extends Primitive {
   Reference<Primitive> value;
   final DartType dartType;
 
-  /// If [type] is an [InterfaceType], this holds the internal representation of
-  /// the type arguments to [type]. Since these may reference type variables
-  /// from the enclosing class, they are not constant.
+  /// If [dartType] is an [InterfaceType], this holds the internal
+  /// representation of the type arguments to [dartType]. Since these may
+  /// reference type variables from the enclosing class, they are not constant.
   ///
-  /// If [type] is a [TypeVariableType], this is a singleton list with
-  /// the internal representation of the type held in that type variable.
+  /// If [dartType] is a [TypeVariableType], this is a singleton list with the
+  /// internal representation of the type held in that type variable.
   ///
-  /// If [type] is a [FunctionType], this is a singleton list with the
+  /// If [dartType] is a [FunctionType], this is a singleton list with the
   /// internal representation of that type,
   ///
   /// Otherwise the list is empty.
   final List<Reference<Primitive>> typeArguments;
 
+  /// The Interceptor for [value].  May be `null` if the test can be done
+  /// without an interceptor.  May be the same as [value] after self-interceptor
+  /// optimization.
+  // TODO(24523): Remove this field.
+  Reference<Primitive> interceptor;
+
   TypeTest(Primitive value,
            this.dartType,
            List<Primitive> typeArguments)
-  : this.value = new Reference<Primitive>(value),
-    this.typeArguments = _referenceList(typeArguments);
+      : this.value = new Reference<Primitive>(value),
+        this.typeArguments = _referenceList(typeArguments);
 
   accept(Visitor visitor) => visitor.visitTypeTest(this);
 
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 }
 
+/// An "is" type test for a raw type, performed by testing a flag property.
+///
+/// Returns `true` if [interceptor] is for [dartType].
+class TypeTestViaFlag extends Primitive {
+  Reference<Primitive> interceptor;
+  final DartType dartType;
+
+  TypeTestViaFlag(Primitive interceptor, this.dartType)
+      : this.interceptor = new Reference<Primitive>(interceptor);
+
+  accept(Visitor visitor) => visitor.visitTypeTestViaFlag(this);
+
+  bool get isSafeForElimination => true;
+  bool get isSafeForReordering => true;
+}
+
 /// An "as" type cast.
 ///
 /// If [value] is `null` or is an instance of [type], [continuation] is invoked
 /// with [value] as argument. Otherwise, a [CastError] is thrown.
 ///
 /// Discussion:
 /// The parameter to [continuation] is redundant since it will always equal
 /// [value], which is typically in scope in the continuation. However, it might
 /// simplify type propagation, since a better type can be computed for the
 /// continuation parameter without needing flow-sensitive analysis.
@@ skipping 737 matching lines @@
   T visitGetStatic(GetStatic node);
   T visitInterceptor(Interceptor node);
   T visitCreateInstance(CreateInstance node);
   T visitGetField(GetField node);
   T visitCreateBox(CreateBox node);
   T visitReifyRuntimeType(ReifyRuntimeType node);
   T visitReadTypeVariable(ReadTypeVariable node);
   T visitTypeExpression(TypeExpression node);
   T visitCreateInvocationMirror(CreateInvocationMirror node);
   T visitTypeTest(TypeTest node);
+  T visitTypeTestViaFlag(TypeTestViaFlag node);
   T visitApplyBuiltinOperator(ApplyBuiltinOperator node);
   T visitApplyBuiltinMethod(ApplyBuiltinMethod node);
   T visitGetLength(GetLength node);
   T visitGetIndex(GetIndex node);
   T visitSetIndex(SetIndex node);
   T visitRefinement(Refinement node);
 
   // Support for literal foreign code.
   T visitForeignCode(ForeignCode node);
 }
@@ skipping 105 matching lines @@
     processTypeCast(node);
     processReference(node.continuation);
     processReference(node.value);
     node.typeArguments.forEach(processReference);
   }
 
   processTypeTest(TypeTest node) {}
   visitTypeTest(TypeTest node) {
     processTypeTest(node);
     processReference(node.value);
+    if (node.interceptor != null) processReference(node.interceptor);
     node.typeArguments.forEach(processReference);
   }
 
+  processTypeTestViaFlag(TypeTestViaFlag node) {}
+  visitTypeTestViaFlag(TypeTestViaFlag node) {
+    processTypeTestViaFlag(node);
+    processReference(node.interceptor);
+  }
+
   processSetMutable(SetMutable node) {}
   visitSetMutable(SetMutable node) {
     processSetMutable(node);
     processReference(node.variable);
     processReference(node.value);
   }
 
   processGetLazyStatic(GetLazyStatic node) {}
   visitGetLazyStatic(GetLazyStatic node) {
     processGetLazyStatic(node);
@@ skipping 305 matching lines @@
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends RecursiveVisitor {
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (new RemovalVisitor()).visit(node);
   }
 }