dart2js cps: Handle error cases.

pkg/compiler/lib/src/tree_ir/optimization/statement_rewriter.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.
 
 part of tree_ir.optimization;
 
 /**
  * Performs the following transformations on the tree:
  * - Assignment inlining
  * - Assignment expression propagation
@@ skipping 252 matching lines @@
 
   /// Returns true if [exp] has no side effects and has a constant value within
   /// any given activation of the enclosing method.
   bool isEffectivelyConstant(Expression exp) {
     // TODO(asgerf): Can be made more aggressive e.g. by checking conditional
     // expressions recursively. Determine if that is a valuable optimization
     // and/or if it is better handled at the CPS level.
     return exp is Constant ||
            exp is This ||
            exp is ReifyTypeVar ||
+           exp is CreateInvocationMirror ||
            exp is InvokeStatic && exp.isEffectivelyConstant ||
            exp is VariableUse && constantEnvironment.containsKey(exp.variable);
   }
 
   /// True if [node] is an assignment that can be propagated as a constant.
   bool isEffectivelyConstantAssignment(Expression node) {
     return node is Assign &&
            node.variable.writeCount == 1 &&
            isEffectivelyConstant(node.value);
   }
@@ skipping 323 matching lines @@
   Expression visitReifyRuntimeType(ReifyRuntimeType node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
   Expression visitReadTypeVariable(ReadTypeVariable node) {
     node.target = visitExpression(node.target);
     return node;
   }
 
-  @override
   Expression visitTypeExpression(TypeExpression node) {
     for (int i = node.arguments.length - 1; i >= 0; --i) {
       node.arguments[i] = visitExpression(node.arguments[i]);
     }
     return node;
   }
 
+  Expression visitCreateInvocationMirror(CreateInvocationMirror node) {
+    for (int i = node.arguments.length - 1; i >= 0; --i) {
+      node.arguments[i] = visitExpression(node.arguments[i]);
+    }
+    return node;
+  }
+
   /// If [s] and [t] are similar statements we extract their subexpressions
   /// and returns a new statement of the same type using expressions combined
   /// with the [combine] callback. For example:
   ///
   ///   combineStatements(Return E1, Return E2) = Return combine(E1, E2)
   ///
   /// If [combine] returns E1 then the unified statement is equivalent to [s],
   /// and if [combine] returns E2 the unified statement is equivalence to [t].
   ///
   /// It is guaranteed that no side effects occur between the beginning of the
@@ skipping 284 matching lines @@
 }
 
 /// Result of combining two expressions that do not affect reference counting.
 class GenericCombinedExpressions implements CombinedExpressions {
   Expression combined;
 
   GenericCombinedExpressions(this.combined);
 
   void uncombine() {}
 }