Change new List(n) to return fixed length list.

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 337 matching lines @@
       node.element = cls.lookupSelector(selector);
     }
     return node;
   }
 
   bool isFixedSizeListConstructor(HInvokeStatic node) {
     Element element = node.target.element;
     if (backend.fixedLengthListConstructor == null) {
       backend.fixedLengthListConstructor =
         compiler.listClass.lookupConstructor(
-            new Selector.callConstructor(const SourceString("fixedLength"),
+            new Selector.callConstructor(const SourceString(""),
                                          compiler.listClass.getLibrary()));
     }
     // TODO(ngeoffray): checking if the second input is an integer
     // should not be necessary but it currently makes it easier for
     // other optimizations to reason on a fixed length constructor
     // that we know takes an int.
     return element == backend.fixedLengthListConstructor
+        && node.inputs.length == 2
         && node.inputs[1].isInteger();
   }
 
   HInstruction visitInvokeStatic(HInvokeStatic node) {
     if (isFixedSizeListConstructor(node)) {
       node.instructionType = HType.FIXED_ARRAY;
     }
     return node;
   }
 
@@ skipping 214 matching lines @@
                                             Selector selector) {
     HType receiverType = receiver.instructionType;
     return compiler.world.locateSingleField(
         receiverType.refine(selector, compiler));
   }
 
   HInstruction visitFieldGet(HFieldGet node) {
     if (node.element == backend.jsArrayLength) {
       if (node.receiver is HInvokeStatic) {
         // Try to recognize the length getter with input
-        // [:new List.fixedLength(int):].
+        // [:new List(int):].
         HInvokeStatic call = node.receiver;
         if (isFixedSizeListConstructor(call)) {
           return call.inputs[1];
         }
       }
     }
     return node;
   }
 
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
@@ skipping 470 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>.fixedLength(length);
-    loopChangesFlags = new List<int>.fixedLength(length);
+    blockChangesFlags = new List<int>(length);
+    loopChangesFlags = new List<int>(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 54 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>.fixedLength(graph.blocks.length);
+    values = new List<ValueSet>(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 356 matching lines @@
     HBasicBlock block = user.block;
     block.addAfter(user, interceptor);
     block.rewrite(user, interceptor);
     block.remove(user);
 
     // The interceptor will be removed in the dead code elimination
     // phase. Note that removing it here would not work because of how
     // the [visitBasicBlock] is implemented.
   }
 }