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

pkg/compiler/lib/src/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 37 matching lines @@
           new SsaTypePropagator(compiler),
           // Run a dead code eliminator before LICM because dead
           // interceptors are often in the way of LICM'able instructions.
           new SsaDeadCodeEliminator(compiler, this),
           new SsaGlobalValueNumberer(compiler),
           // After GVN, some instructions might need their type to be
           // updated because they now have different inputs.
           new SsaTypePropagator(compiler),
           new SsaCodeMotion(),
           new SsaLoadElimination(compiler),
+          new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
           new SsaTypePropagator(compiler),
           new SsaValueRangeAnalyzer(compiler, constantSystem, this, work),
           // Previous optimizations may have generated new
           // opportunities for instruction simplification.
           new SsaInstructionSimplifier(constantSystem, backend, this, work),
           new SsaCheckInserter(
               trustPrimitives, backend, work, context.boundsChecked),
       ];
       phases.forEach(runPhase);
@@ skipping 122 matching lines @@
 
   HInstruction visitInstruction(HInstruction node) {
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
     if (input.isBoolean(compiler)) return input;
+
+    // If the code is unreachable, remove the HBoolify.  This can happen when
+    // there is a throw expression in a short-circuit conditional.  Removing the
+    // unreachable HBoolify makes it easier to reconstruct the short-circuit
+    // operation.
+    if (input.instructionType.isEmpty && !input.instructionType.isNullable)
+      return input;
+
     // All values that cannot be 'true' are boolified to false.
     TypeMask mask = input.instructionType;
     if (!mask.contains(backend.jsBoolClass, compiler.world)) {
       return graph.addConstantBool(false, compiler);
     }
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
@@ skipping 296 matching lines @@
     // in the remaining optimizations.
     return super.visitRelational(node);
   }
 
   HInstruction handleIdentityCheck(HRelational node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     TypeMask leftType = left.instructionType;
     TypeMask rightType = right.instructionType;
 
+    HInstruction makeTrue() => graph.addConstantBool(true, compiler);
+    HInstruction makeFalse() => graph.addConstantBool(false, compiler);
+
     // Intersection of int and double return conflicting, so
     // we don't optimize on numbers to preserve the runtime semantics.
     if (!(left.isNumberOrNull(compiler) && right.isNumberOrNull(compiler))) {
       TypeMask intersection = leftType.intersection(rightType, compiler.world);
       if (intersection.isEmpty && !intersection.isNullable) {
-        return graph.addConstantBool(false, compiler);
+        return makeFalse();
       }
     }
 
     if (left.isNull() && right.isNull()) {
-      return graph.addConstantBool(true, compiler);
+      return makeTrue();
+    }
+
+    HInstruction compareConstant(HConstant constant, HInstruction input) {
+      if (constant.constant.isTrue) {
+        return input;
+      } else {
+        return new HNot(input, backend.boolType);
+      }
     }
 
     if (left.isConstantBoolean() && right.isBoolean(compiler)) {
-      HConstant constant = left;
-      if (constant.constant.isTrue) {
-        return right;
-      } else {
-        return new HNot(right, backend.boolType);
-      }
+      return compareConstant(left, right);
     }
 
     if (right.isConstantBoolean() && left.isBoolean(compiler)) {
-      HConstant constant = right;
-      if (constant.constant.isTrue) {
-        return left;
-      } else {
-        return new HNot(left, backend.boolType);
-      }
+      return compareConstant(right, left);
+    }
+
+
+    if (identical(left.nonCheck(), right.nonCheck())) {
+      // Avoid constant-folding `identical(x, x)` when `x` might be double.  The
+      // dart2js runtime has not always been consistent with the Dart
+      // specification (section 16.0.1), which makes distinctions on NaNs and
+      // -0.0 that are hard to implement efficiently.
+      if (left.isIntegerOrNull(compiler)) return makeTrue();
+      if (!left.canBePrimitiveNumber(compiler)) return makeTrue();
     }
 
     return null;
   }
 
   HInstruction visitIdentity(HIdentity node) {
     HInstruction newInstruction = handleIdentityCheck(node);
     return newInstruction == null ? super.visitIdentity(node) : newInstruction;
   }
 
@@ skipping 260 matching lines @@
           type,
           HTypeConversion.CHECKED_MODE_CHECK);
       if (other != value) {
         node.block.addBefore(node, other);
         value = other;
       }
     }
     return new HFieldSet(field, receiver, value);
   }
 
+  HInstruction visitInvokeStatic(HInvokeStatic node) {
+    if (node.element == backend.getCheckConcurrentModificationError()) {
+      if (node.inputs.length == 2) {
+        HInstruction firstArgument = node.inputs[0];
+        if (firstArgument is HConstant) {
+          HConstant constant = firstArgument;
+          if (constant.constant.isTrue) return constant;
+        }
+      }
+    }
+    return node;
+  }
+
   HInstruction visitStringConcat(HStringConcat node) {
     // Simplify string concat:
     //
     //     "" + R                ->  R
     //     L + ""                ->  L
     //     "L" + "R"             ->  "LR"
     //     (prefix + "L") + "R"  ->  prefix + "LR"
     //
     StringConstantValue getString(HInstruction instruction) {
       if (!instruction.isConstantString()) return null;
@@ skipping 1411 matching lines @@
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }