tree-ir: Treat getInterceptor and identical as effectively constant.

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 198 matching lines @@
     // We traverse the tree right-to-left, so when we have seen all uses,
     // it means we are looking at the first use.
     assert(seenUses[node.variable] <= node.variable.readCount);
     bool isFirstUse = seenUses[node.variable] == node.variable.readCount;
 
     // Propagate constant to use site.
     Expression constant = constantEnvironment[node.variable];
     if (constant != null) {
       --node.variable.readCount;
       --seenUses[node.variable]; // Do not count the use we just destroyed.
-      return constant;
+      return visitExpression(constant);
     }
 
     // Try to propagate another expression into this variable use.
     if (!environment.isEmpty) {
       Expression binding = environment.last;
 
       // Is this variable assigned by the most recently evaluated impure
       // expression?
       //
       // If so, propagate the assignment, e.g:
@@ skipping 33 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 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);
   }
 
   Statement visitExpressionStatement(ExpressionStatement stmt) {
     if (isEffectivelyConstantAssignment(stmt.expression)) {
       Assign assign = stmt.expression;
       // Handle constant assignments specially.
       // They are always safe to propagate (though we should avoid duplication).
       // Moreover, they should not prevent other expressions from propagating.
       if (assign.variable.readCount <= 1) {
         // A single-use constant should always be propagted to its use site.
-        constantEnvironment[assign.variable] = visitExpression(assign.value);
+        constantEnvironment[assign.variable] = assign.value;
         --assign.variable.writeCount;
         return visitStatement(stmt.next);
       } else {
         // With more than one use, we cannot propagate the constant.
         // Visit the following statement without polluting [environment] so
         // that any preceding non-constant assignments might still propagate.
         stmt.next = visitStatement(stmt.next);
         assign.value = visitExpression(assign.value);
         return stmt;
       }
@@ skipping 606 matching lines @@
 }
 
 /// Result of combining two expressions that do not affect reference counting.
 class GenericCombinedExpressions implements CombinedExpressions {
   Expression combined;
 
   GenericCombinedExpressions(this.combined);
 
   void uncombine() {}
 }