Mark some string operations as GVN-able.

pkg/compiler/lib/src/ssa/invoke_dynamic_specializers.dart

 // Copyright (c) 2013, 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.
 
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
 import '../elements/elements.dart';
 import '../js_backend/js_backend.dart';
 import '../types/types.dart';
@@ skipping 54 matching lines @@
       if (name == '<=') return const LessEqualSpecializer();
       if (name == '>') return const GreaterSpecializer();
       if (name == '>=') return const GreaterEqualSpecializer();
       return const InvokeDynamicSpecializer();
     }
     if (selector.isCall) {
       if (selector.namedArguments.length == 0) {
         int argumentCount = selector.argumentCount;
         if (argumentCount == 0) {
           if (name == 'round') return const RoundSpecializer();
+          if (name == 'trim') return const TrimSpecializer();
         } else if (argumentCount == 1) {
           if (name == 'codeUnitAt') return const CodeUnitAtSpecializer();
           if (name == 'remainder') return const RemainderSpecializer();
+          if (name == 'substring') return const SubstringSpecializer();
+          if (name == 'contains') return const PatternMatchSpecializer();
+          if (name == 'indexOf') return const PatternMatchSpecializer();
+          if (name == 'startsWith') return const PatternMatchSpecializer();
+          if (name == 'endsWith') return const PatternMatchSpecializer();
+        } else if (argumentCount == 2) {
+          if (name == 'substring') return const SubstringSpecializer();
+          if (name == 'contains') return const PatternMatchSpecializer();
+          if (name == 'indexOf') return const PatternMatchSpecializer();
+          if (name == 'startsWith') return const PatternMatchSpecializer();
+          if (name == 'endsWith') return const PatternMatchSpecializer();
         }
       }
     }
     return const InvokeDynamicSpecializer();
   }
 }
 
 class IndexAssignSpecializer extends InvokeDynamicSpecializer {
   const IndexAssignSpecializer();
 
@@ skipping 752 matching lines @@
     if (receiver.isStringOrNull(closedWorld)) {
       // Even if there is no builtin equivalent instruction, we know
       // String.codeUnitAt does not have any side effect (other than throwing),
       // and that it can be GVN'ed.
       clearAllSideEffects(instruction);
     }
     return null;
   }
 }
 
+class IdempotentStringOperationSpecializer extends InvokeDynamicSpecializer {
+  const IdempotentStringOperationSpecializer();
+
+  HInstruction tryConvertToBuiltin(
+      HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
+    HInstruction receiver = instruction.getDartReceiver(closedWorld);
+    if (receiver.isStringOrNull(closedWorld)) {
+      // String.xxx does not have any side effect (other than throwing), and it
+      // can be GVN'ed.
+      clearAllSideEffects(instruction);
+    }
+    return null;
+  }
+}
+
+class SubstringSpecializer extends IdempotentStringOperationSpecializer {
+  const SubstringSpecializer();
+}
+
+class TrimSpecializer extends IdempotentStringOperationSpecializer {
+  const TrimSpecializer();
+}
+
+class PatternMatchSpecializer extends InvokeDynamicSpecializer {
+  const PatternMatchSpecializer();
+
+  HInstruction tryConvertToBuiltin(
+      HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
+    HInstruction receiver = instruction.getDartReceiver(closedWorld);
+    HInstruction pattern = instruction.inputs[2];
+    if (receiver.isStringOrNull(closedWorld) &&
+        pattern.isStringOrNull(closedWorld)) {
+      // String.contains(String s) does not have any side effect (other than
+      // throwing), and it can be GVN'ed.
+      clearAllSideEffects(instruction);
+    }
+    return null;
+  }
+}
+
 class RoundSpecializer extends InvokeDynamicSpecializer {
   const RoundSpecializer();
 
   UnaryOperation operation(ConstantSystem constantSystem) {
     return constantSystem.round;
   }
 
   HInstruction tryConvertToBuiltin(
       HInvokeDynamic instruction, Compiler compiler, ClosedWorld closedWorld) {
     HInstruction receiver = instruction.getDartReceiver(closedWorld);
     if (receiver.isNumberOrNull(closedWorld)) {
       // Even if there is no builtin equivalent instruction, we know the
       // instruction does not have any side effect, and that it can be GVN'ed.
       clearAllSideEffects(instruction);
     }
     return null;
   }
 }