dart2js cps: Use TypeMaskSystem when inserting refinement nodes.

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

 // Copyright (c) 2015, 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 cps_ir.optimization.insert_refinements;
 
 import 'optimizers.dart' show Pass;
 import 'shrinking_reductions.dart' show ParentVisitor;
 import 'cps_ir_nodes.dart';
-import '../types/types.dart';
 import '../types/constants.dart';
 import '../constants/values.dart';
-import '../world.dart';
 import '../common/names.dart';
 import '../universe/universe.dart';
 import '../elements/elements.dart';
+import '../types/types.dart' show TypeMask;
+import 'type_mask_system.dart';
 
 /// Inserts [Refinement] nodes in the IR to allow for sparse path-sensitive
 /// type analysis in the [TypePropagator] pass.
 ///
 /// Refinement nodes are inserted at the arms of a [Branch] node with a
 /// condition of form `x is T` or `x == null`.
 ///
 /// Refinement nodes are inserted after a method invocation to refine the
 /// receiver to the types that can respond to the given selector.
 class InsertRefinements extends RecursiveVisitor implements Pass {
   String get passName => 'Insert refinement nodes';
 
-  final TypesTask types;
-  final World world;
-  final TypeMask nonNullType;
-  final TypeMask nullType;
+  final TypeMaskSystem types;
 
   /// Maps unrefined primitives to its refinement currently in scope (if any).
   final Map<Primitive, Refinement> refinementFor = <Primitive, Refinement>{};
 
-  InsertRefinements(this.types, World world)
-    : this.world = world,
-      nonNullType = new TypeMask.nonNullSubtype(world.objectClass, world),
-      nullType = new TypeMask.empty();
+  InsertRefinements(this.types);
 
   void rewrite(FunctionDefinition node) {
     new ParentVisitor().visit(node);
     visit(node.body);
   }
 
   /// Updates references to refer to the refinement currently in scope.
   void processReference(Reference node) {
     Refinement refined = refinementFor[node.definition];
     if (refined != null) {
@@ skipping 76 matching lines @@
     // Sink the continuation to the call to ensure everything in scope
     // here is also in scope inside the continuations.
     sinkContinuationToUse(cont, node);
 
     if (node.selector.isClosureCall) {
       // Do not try to refine the receiver of closure calls; the class world
       // does not know about closure classes.
       push(cont);
     } else {
       // Filter away receivers that throw on this selector.
-      TypeMask type = world.allFunctions.receiverType(node.selector, node.mask);
+      TypeMask type = types.receiverTypeFor(node.selector, node.mask);
       pushRefinement(cont, new Refinement(receiver, type));
     }
   }
 
   CallExpression getCallWithResult(Primitive prim) {
     if (prim is Parameter && prim.parent is Continuation) {
       Continuation cont = prim.parent;
       if (cont.hasExactlyOneUse && cont.firstRef.parent is CallExpression) {
         return cont.firstRef.parent;
       }
     }
     return null;
   }
 
   bool isTrue(Primitive prim) {
     return prim is Constant && prim.value.isTrue;
   }
 
-  TypeMask getTypeOf(ConstantValue constant) {
-    return computeTypeMask(types.compiler, constant);
-  }
-
   void visitBranch(Branch node) {
     processReference(node.condition);
     Primitive condition = node.condition.definition;
     CallExpression call = getCallWithResult(condition);
 
     Continuation trueCont = node.trueContinuation.definition;
     Continuation falseCont = node.falseContinuation.definition;
 
     // Sink both continuations to the Branch to ensure everything in scope
     // here is also in scope inside the continuations.
     sinkContinuationToUse(trueCont, node);
     sinkContinuationToUse(falseCont, node);
 
     // If the condition is an 'is' check, promote the checked value.
-    if (condition is TypeTest && condition.type.element is ClassElement) {
+    if (condition is TypeTest) {
       Primitive value = condition.value.definition;
-      ClassElement classElement = condition.type.element;
-      TypeMask type = new TypeMask.nonNullSubtype(classElement, world);
+      TypeMask type = types.subtypesOf(condition.type);
       Primitive refinedValue = new Refinement(value, type);
       pushRefinement(trueCont, refinedValue);
       push(falseCont);
       return;
     }
 
     // If the condition is comparison with a constant, promote the other value.
     // This can happen either for calls to `==` or `identical` calls, such
     // as the ones inserted by the unsugaring pass.
 
     void refineEquality(Primitive first,
                         Primitive second,
                         Continuation trueCont,
                         Continuation falseCont) {
       if (second is Constant && second.value.isNull) {
-        Refinement refinedTrue = new Refinement(first, nullType);
-        Refinement refinedFalse = new Refinement(first, nonNullType);
+        Refinement refinedTrue = new Refinement(first, types.nullType);
+        Refinement refinedFalse = new Refinement(first, types.nonNullType);
         pushRefinement(trueCont, refinedTrue);
         pushRefinement(falseCont, refinedFalse);
       } else if (first is Constant && first.value.isNull) {
-        Refinement refinedTrue = new Refinement(second, nullType);
-        Refinement refinedFalse = new Refinement(second, nonNullType);
+        Refinement refinedTrue = new Refinement(second, types.nullType);
+        Refinement refinedFalse = new Refinement(second, types.nonNullType);
         pushRefinement(trueCont, refinedTrue);
         pushRefinement(falseCont, refinedFalse);
       } else {
         push(trueCont);
         push(falseCont);
       }
     }
 
     if (call is InvokeMethod && call.selector == Selectors.equals) {
       refineEquality(call.arguments[0].definition,
@@ skipping 24 matching lines @@
            cont.firstRef.parent is Branch)) {
         // Do not push the continuation here.
         // visitInvokeMethod and visitBranch will do that.
       } else {
         push(cont);
       }
     }
     return node.body;
   }
 }