Put back manual inlining of List.add, List.removeLast, String.split and String.concat.

sdk/lib/_internal/compiler/implementation/ssa/optimize.dart

 // Copyright (c) 2012, 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 ssa;
 
 abstract class OptimizationPhase {
   String get name;
   void visitGraph(HGraph graph);
 }
@@ skipping 21 matching lines @@
     ConstantSystem constantSystem = compiler.backend.constantSystem;
     JavaScriptItemCompilationContext context = work.compilationContext;
     HTypeMap types = context.types;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
           // Run trivial constant folding first to optimize
           // some patterns useful for type conversion.
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaTypeConversionInserter(compiler),
           new SsaTypePropagator(compiler, types),
+          new SsaConstantFolder(constantSystem, backend, work, types),

[ahe, 2012/11/30 08:11:42]

Add a comment explaining why you call the constant folder again?

           new SsaCheckInserter(backend, work, types, context.boundsChecked),
-          new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaConstantFolder(constantSystem, backend, work, types),
           new SsaTypePropagator(compiler, types),
           new SsaReceiverSpecialization(compiler),
           new SsaGlobalValueNumberer(compiler, types),
           new SsaCodeMotion(),
           new SsaValueRangeAnalyzer(constantSystem, types, work),
           // Previous optimizations may have generated new
           // opportunities for constant folding.
@@ skipping 146 matching lines @@
     if (operand is HConstant) {
       UnaryOperation operation = node.operation(constantSystem);
       HConstant receiver = operand;
       Constant folded = operation.fold(receiver.constant);
       if (folded != null) return graph.addConstant(folded);
     }
     return node;
   }
 
   HInstruction handleInterceptorCall(HInvokeDynamic node) {
+    if (node is !HInvokeDynamicMethod) return;

[ahe, 2012/11/30 08:11:42]

I don't understand this line.

     HInstruction input = node.inputs[1];
     if (input.isString(types)
         && node.selector.name == const SourceString('toString')) {
       return node.inputs[1];
     }
     // Check if this call does not need to be intercepted.
     HType type = types[input];
     var interceptor = node.inputs[0];
-    if (node is HInvokeDynamicMethod
-        && interceptor is !HThis
-        && !type.canBePrimitive()) {
+    if (interceptor is !HThis && !type.canBePrimitive()) {
       // If the type can be null, and the intercepted method can be in
       // the object class, keep the interceptor.
       if (type.canBeNull()
           && interceptor.interceptedClasses.contains(compiler.objectClass)) {
         return node;
       }
       // Change the call to a regular invoke dynamic call.
       return new HInvokeDynamicMethod(
           node.selector, node.inputs.getRange(1, node.inputs.length - 1));
     }
+
+    Selector selector = node.selector;
+    SourceString selectorName = selector.name;
+    Element target;
+    if (input.isExtendableArray(types)) {
+      if (selectorName == backend.jsArrayRemoveLast.name
+          && selector.argumentCount == 0) {

[ahe, 2012/11/30 08:11:42]

Why isn't this selector.applies(backend.jsArrayRemoveLast)?

+        target = backend.jsArrayRemoveLast;
+      } else if (selectorName == backend.jsArrayAdd.name
+                 && selector.argumentCount == 1
+                 && selector.namedArgumentCount == 0
+                 && !compiler.enableTypeAssertions) {
+        target = backend.jsArrayAdd;
+      }
+    } else if (input.isString(types)) {
+      if (selectorName == backend.jsStringSplit.name
+          && selector.argumentCount == 1
+          && selector.namedArgumentCount == 0
+          && node.inputs[2].isString(types)) {
+        target = backend.jsStringSplit;
+      } else if (selectorName == backend.jsStringConcat.name
+                 && selector.argumentCount == 1
+                 && selector.namedArgumentCount == 0
+                 && node.inputs[2].isString(types)) {
+        target = backend.jsStringConcat;
+      }
+    }
+    if (target != null) {
+      HInvokeDynamicMethod result = new HInvokeDynamicMethod(
+          node.selector, node.inputs.getRange(1, node.inputs.length - 1));
+      result.element = target;
+      return result;
+    }
     return node;
   }
 
   bool isFixedSizeListConstructor(HInvokeStatic node) {
     Element element = node.target.element;
     return element.getEnclosingClass() == compiler.listClass
         && node.inputs.length == 2
         && node.inputs[1].isInteger(types);
   }
 
@@ skipping 469 matching lines @@
     ConstantHandler handler = compiler.constantHandler;
     Constant constant = new ConstructedConstant(
         constantInterceptor.computeType(compiler), <Constant>[]);
     handler.registerCompileTimeConstant(constant);
     return graph.addConstant(constant);
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
   final HTypeMap types;
-  final ConstantSystem constantSystem;
   final Set<HInstruction> boundsChecked;
   final WorkItem work;
+  final JavaScriptBackend backend;
   final String name = "SsaCheckInserter";
   HGraph graph;
-  Element lengthInterceptor;
 
-  SsaCheckInserter(JavaScriptBackend backend,
+  SsaCheckInserter(this.backend,
                    this.work,
                    this.types,
-                   this.boundsChecked)
-      : constantSystem = backend.constantSystem {
-    lengthInterceptor = backend.jsArrayLength;
-  }
+                   this.boundsChecked);
 
   void visitGraph(HGraph graph) {
     this.graph = graph;
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction != null) {
       HInstruction next = instruction.next;
       instruction = instruction.accept(this);
       instruction = next;
     }
   }
 
   HBoundsCheck insertBoundsCheck(HInstruction node,
                                  HInstruction receiver,
                                  HInstruction index) {
     bool isAssignable = !receiver.isFixedArray(types);
-    HFieldGet length =
-        new HFieldGet(lengthInterceptor, receiver, isAssignable: isAssignable);
+    HFieldGet length = new HFieldGet(
+        backend.jsArrayLength, receiver, isAssignable: isAssignable);
     length.guaranteedType = HType.INTEGER;
     types[length] = HType.INTEGER;
     node.block.addBefore(node, length);
 
     HBoundsCheck check = new HBoundsCheck(index, length);
     node.block.addBefore(node, check);
     boundsChecked.add(node);
     return check;
   }
 
@@ skipping 23 matching lines @@
     if (!node.receiver.isMutableArray(types)) return;
     if (boundsChecked.contains(node)) return;
     HInstruction index = node.index;
     if (!node.index.isInteger(types)) {
       index = insertIntegerCheck(node, index);
     }
     index = insertBoundsCheck(node, node.receiver, index);
     node.changeUse(node.index, index);
     assert(node.isBuiltin(types));
   }
+
+  void visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
+    Element element = node.element;
+    if (element != backend.jsArrayRemoveLast) return;
+    if (boundsChecked.contains(node)) return;
+    insertBoundsCheck(
+        node, node.receiver, graph.addConstantInt(0, backend.constantSystem));
+  }
 }
 
 class SsaDeadCodeEliminator extends HGraphVisitor implements OptimizationPhase {
   final HTypeMap types;
   final String name = "SsaDeadCodeEliminator";
 
   SsaDeadCodeEliminator(this.types);
 
   bool isDeadCode(HInstruction instruction) {
     return !instruction.hasSideEffects(types)
@@ skipping 631 matching lines @@
     HInstruction receiver = interceptor.receiver;
     for (var user in receiver.usedBy) {
       if (user is HInterceptor && interceptor.dominates(user)) {
         user.interceptedClasses = interceptor.interceptedClasses;
       }
     }
   }
 
   // TODO(ngeoffray): Also implement it for non-intercepted calls.
 }