dart2js cps: Support --trust-primitives and --trust-type-annotations.

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 'cps_ir_nodes.dart';
 import '../common/names.dart';
 import '../types/types.dart' show TypeMask;
 import 'type_mask_system.dart';
+import 'cps_fragment.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 TrampolineRecursiveVisitor implements Pass {
   String get passName => 'Insert refinement nodes';
 
   final TypeMaskSystem types;
 
   /// Maps unrefined primitives to its refinement currently in scope (if any).
   final Map<Primitive, Refinement> refinementFor = <Primitive, Refinement>{};
 
   InsertRefinements(this.types);
 
   void rewrite(FunctionDefinition 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) {
-      node.changeTo(refined);
+    Definition definition = node.definition;
+    if (definition is Primitive) {
+      Primitive prim = definition.effectiveDefinition;
+      Refinement refined = refinementFor[prim];
+      if (refined != null && refined != definition) {
+        node.changeTo(refined);
+      }
     }
   }
 
   /// Sinks the binding of [cont] to immediately above [use].
   ///
   /// This is used to ensure that everything in scope at [use] is also in scope
   /// inside [cont], so refinements can be inserted inside [cont] without
   /// accidentally referencing a primitive out of scope.
   ///
   /// It is always safe to do this for single-use continuations, because
@@ skipping 61 matching lines @@
       // does not know about closure classes.
       push(cont);
     } else {
       // Filter away receivers that throw on this selector.
       TypeMask type = types.receiverTypeFor(node.selector, node.mask);
       Refinement refinement = new Refinement(receiver, type);
       pushRefinement(cont, refinement);
     }
   }
 
+  void visitTypeCast(TypeCast node) {
+    Continuation cont = node.continuation.definition;
+    Primitive value = node.value.definition;
+
+    processReference(node.value);
+    node.typeArguments.forEach(processReference);
+
+    // Refine the type of the input.
+    sinkContinuationToUse(cont, node);
+    TypeMask type = types.subtypesOf(node.dartType).nullable();
+    Refinement refinement = new Refinement(value, type);
+    pushRefinement(cont, refinement);
+  }
+
+  void visitRefinement(Refinement node) {
+    // We found a pre-existing refinement node. These are generated by the
+    // IR builder to hold information from --trust-type-annotations.
+    // Update its input to use our own current refinement, then update the
+    // environment to use this refinement.
+    processReference(node.value);
+    Primitive value = node.value.definition.effectiveDefinition;
+    Primitive oldRefinement = refinementFor[value];
+    refinementFor[value] = node;
+    pushAction(() {
+      refinementFor[value] = oldRefinement;
+    });
+  }
+
   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;
   }
 
@@ skipping 67 matching lines @@
 
     push(trueCont);
     push(falseCont);
   }
 
   @override
   Expression traverseLetCont(LetCont node) {
     for (Continuation cont in node.continuations) {
       if (cont.hasExactlyOneUse &&
           (cont.firstRef.parent is InvokeMethod ||
+           cont.firstRef.parent is TypeCast ||
            cont.firstRef.parent is Branch)) {
         // Do not push the continuation here.
-        // visitInvokeMethod and visitBranch will do that.
+        // visitInvokeMethod, visitBranch, and visitTypeCast will do that.
       } else {
         push(cont);
       }
     }
     return node.body;
   }
 }