Rewrite for-in loop as indexing loop for JavaScript indexable arrays

pkg/compiler/lib/src/ssa/builder.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;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 5612 matching lines @@
       add(result);
       return result;
     }
 
     void buildConcurrentModificationErrorCheck() {
       if (originalLength == null) return;
       // Generate shortcircuit expression:
       //
       //     array.length == _end || throwConcurrentModificationError(array)
       //
+      /*
       SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
       branchBuilder.handleLogicalAndOr(
           () {
             HInstruction length = buildGetLength();
             push(new HIdentity(length, originalLength, null, boolType));
           },
           () {
             pushInvokeStatic(node,
                 backend.getThrowConcurrentModificationError(),
                 [array]);
           },
           isAnd: false);
       pop();
+      */
+      HInstruction length = buildGetLength();
+      push(new HIdentity(length, originalLength, null, boolType));
+      pushInvokeStatic(node,
+          backend.getThrowConcurrentModificationError(),
+          [pop(), array]);
+      pop();
     }
 
     void buildInitializer() {
       visit(node.expression);
       array = pop();
       isFixed = isFixedLength(array.instructionType, compiler);
       localsHandler.updateLocal(indexVariable,
           graph.addConstantInt(0, compiler));
-      if (!isFixed) {
+      //if (!isFixed) {

[sra1, 2015/04/16 19:27:09]

This will be changed back, was just for debugging lack of optimization of the
check for trivial loops due to redundant phi-knots.

         originalLength = buildGetLength();
-      }
+      //}
     }
 
     HInstruction buildCondition() {
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction length = buildGetLength();
       HInstruction compare = new HLess(index, length, null, boolType);
       add(compare);
       return compare;
     }
 
     void buildBody() {
       // If we had inlined ArrayIterator.moveNext(), it would have done the
       // ConcurrentModificationError check as part of the condition.  Putting
       // the check in the condition or in the update generates terrible code
       // because we don't manage to reconstruct the short-circuit expression
       // which forces the for(;;) to be generated as a while loop.
       //
       // For now we will put the check in the body, which will miss a
       // modification on the last iteration.
-      buildConcurrentModificationErrorCheck();
+      //buildConcurrentModificationErrorCheck();
 
       // Find a type for the element.
       // Use the element type of the indexer into the array.
       // TODO(sra): The array type can be better, e.g. a container type.
 
       Selector selector = new Selector.index();
       Selector refined = new TypedSelector(arrayType, selector, compiler.world);
       TypeMask type =
           TypeMaskFactory.inferredTypeForSelector(refined, compiler);
 
@@ skipping 19 matching lines @@
             location: identifier);
       } else {
         generateNonInstanceSetter(
             null, loopVariable, value, location: identifier);
       }
       pop(); // Pop the value pushed by the setter call.
 
       visit(node.body);
     }
     void buildUpdate() {
+      buildConcurrentModificationErrorCheck();
       // TODO(sra): It would be slightly shorter to generate `a[i++]` in the
       // body (and that more closely follows what an inlined iterator would do)
       // but the code is horrible as `i+1` is carried around the loop in an
       // additional variable.
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction one = graph.addConstantInt(1, compiler);
       HInstruction addInstruction =
           new HAdd(index, one, null, backend.positiveIntType);
       add(addInstruction);
       localsHandler.updateLocal(indexVariable, addInstruction);
@@ skipping 1430 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }