Don't constant fold large strings.

pkg/compiler/lib/src/cps_ir/type_propagation.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.
 library dart2js.cps_ir.type_propagation;
 
 import 'optimizers.dart';
 
 import '../closure.dart' show
     ClosureClassElement;
 import '../common.dart';
@@ skipping 828 matching lines @@
     if (prim.hasNoUses && prim.isSafeForElimination) {
       push(node.body);
       prim.destroy();
       node.remove();
       return;
     }
 
     // Try to constant-fold the primitive.
     if (prim is! Constant && prim is! Refinement && prim.isSafeForElimination) {
       AbstractConstantValue value = getValue(prim);
       if (value.isConstant) {

[asgerf, 2015/12/11 12:27:12]

I think we should just do the check here.

[sra1, 2015/12/11 19:13:26]

Done.

         prim.replaceWith(makeConstantPrimitive(value.constant));
         push(node.body);
         return;
       }
     }
 
     // Try to specialize the primitive.
     var replacement = visit(prim);
     if (replacement is CpsFragment) {
       reanalyzeFragment(replacement);
@@ skipping 1674 matching lines @@
 
   /// Sets the type of the given primitive.
   ///
   /// If [updateValue] is a constant and [canReplace] is true, the primitive
   /// is also marked as safe for elimination, so it can be constant-folded.
   void setResult(UnsafePrimitive prim,
                  AbstractConstantValue updateValue,
                  {bool canReplace: false}) {
     // TODO(asgerf): Separate constant folding from side effect analysis.
     setValue(prim, updateValue);
-    prim.isSafeForElimination = canReplace && updateValue.isConstant;
+    prim.isSafeForElimination = canReplace &&
+        updateValue.isConstant &&
+        constantIsSafeToCopy(updateValue.constant);
+  }
+
+  bool constantIsSafeToCopy(ConstantValue constant) {
+    // TODO(25230, 25231): Refer to large shared strings by name.
+    // This number is chosen to prevent huge strings being copied. Don't make
+    // this too small, otherwise it will suppress otherwise harmless constant
+    // folding.
+    const int MAXIMUM_LENGTH_OF_DUPLICATED_STRING = 500;

[asgerf, 2015/12/11 12:27:12]

I think the better place to do this is in visitLetPrim above (I put a comment
there).  The operation itself should still be eliminated if it has no uses.

[sra1, 2015/12/11 19:13:26]

Done.

+    return constant is StringConstantValue
+        ? constant.length < MAXIMUM_LENGTH_OF_DUPLICATED_STRING
+        : true;
   }
 
   bool isInterceptedSelector(Selector selector) {
     return backend.isInterceptedSelector(selector);
   }
 
   // -------------------------- Visitor overrides ------------------------------
   void visit(Node node) { node.accept(this); }
 
   void visitFunctionDefinition(FunctionDefinition node) {
@@ skipping 734 matching lines @@
   processLetPrim(LetPrim node) {
     node.primitive.type = null;
     values[node.primitive] = null;
   }
 
   processLetMutable(LetMutable node) {
     node.variable.type = null;
     values[node.variable] = null;
   }
 }