Big merge from experimental to bleeding edge.

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 252 matching lines @@
       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);
+    if (element.getEnclosingClass() != compiler.listClass) return false;
+    if (!element.isConstructor()) return false;
+    // Check that the constructor is called with an argument and that this
+    // argument is an integer.
+    // TODO(ngeoffray): maybe change the name of the function to reflect that
+    // we also look at the argument.
+    if (node.inputs.length != 2) return false;
+    if (!node.inputs[1].isInteger(types)) return false;
+
+    // TODO(ngeoffray): cache constructor.
+    FunctionElement fixedLengthListConstructor =
+        compiler.listClass.lookupConstructor(
+            new Selector.callConstructor(const SourceString("fixedLength"),
+                                         compiler.listClass.getLibrary()));
+    return element == fixedLengthListConstructor.defaultImplementation;
   }
 
   HInstruction visitInvokeStatic(HInvokeStatic node) {
     if (isFixedSizeListConstructor(node)) {
       node.guaranteedType = HType.FIXED_ARRAY;
     }
     return node;
   }
 
   HInstruction visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
@@ skipping 315 matching lines @@
     if (!receiverType.isUseful()) return null;
     if (receiverType.canBeNull()) return null;
     DartType type = receiverType.computeType(compiler);
     if (type == null) return null;
     return compiler.world.locateSingleField(type, selector);
   }
 
   HInstruction visitFieldGet(HFieldGet node) {
     if (node.element == backend.jsArrayLength) {
       if (node.receiver is HInvokeStatic) {
-        // Try to recognize the length getter with input [:new List(int):].
+        // Try to recognize the length getter with input
+        // [:new List.fixedLength(int):].
         HInvokeStatic call = node.receiver;
         if (isFixedSizeListConstructor(call)) {
           return call.inputs[1];
         }
       }
     }
     return node;
   }
 
   HInstruction optimizeLengthInterceptedCall(HInvokeDynamicGetter node) {
@@ skipping 461 matching lines @@
       }
       visitBasicBlock(dominated, successorValues);
     }
   }
 
   void computeChangesFlags(HGraph graph) {
     // Create the changes flags lists. Make sure to initialize the
     // loop changes flags list to zero so we can use bitwise or when
     // propagating loop changes upwards.
     final int length = graph.blocks.length;
-    blockChangesFlags = new List<int>(length);
-    loopChangesFlags = new List<int>(length);
+    blockChangesFlags = new List<int>.fixedLength(length);
+    loopChangesFlags = new List<int>.fixedLength(length);
     for (int i = 0; i < length; i++) loopChangesFlags[i] = 0;
 
     // Run through all the basic blocks in the graph and fill in the
     // changes flags lists.
     for (int i = length - 1; i >= 0; i--) {
       final HBasicBlock block = graph.blocks[i];
       final int id = block.id;
 
       // Compute block changes flags for the block.
       int changesFlags = 0;
@@ skipping 55 matching lines @@
 //
 // A basic block looks at its sucessors and finds the intersection of
 // these computed ValueSet. It moves all instructions of the
 // intersection into its own list of instructions.
 class SsaCodeMotion extends HBaseVisitor implements OptimizationPhase {
   final String name = "SsaCodeMotion";
 
   List<ValueSet> values;
 
   void visitGraph(HGraph graph) {
-    values = new List<ValueSet>(graph.blocks.length);
+    values = new List<ValueSet>.fixedLength(graph.blocks.length);
     for (int i = 0; i < graph.blocks.length; i++) {
       values[graph.blocks[i].id] = new ValueSet();
     }
     visitPostDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     List<HBasicBlock> successors = block.successors;
 
     // Phase 1: get the ValueSet of all successors (if there are more than one),
@@ skipping 290 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.
 }