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

runtime/vm/snapshot_test.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.
 
 import 'dart:isolate';
 import 'dart:async';
 
 class Fields {
   Fields(int i, int j) : fld1 = i, fld2 = j, fld5 = true {}
   int fld1;
@@ skipping 87 matching lines @@
   final int size;
   TowersDisk next;
 
   TowersDisk(size) : this.size = size, next = null {}
 }
 
 class Towers {
   List<TowersDisk> piles;
   int movesDone;
   Towers(int disks)
-      : piles = new List<TowersDisk>.fixedLength(3), movesDone = 0 {
+      : piles = new List<TowersDisk>(3), movesDone = 0 {
     build(0, disks);
   }
 
   void build(int pile, int disks) {
     for (var i = disks - 1; i >= 0; i--) {
       push(pile, new TowersDisk(i));
     }
   }
 
   void push(int pile, TowersDisk disk) {
@@ skipping 52 matching lines @@
     new TowersBenchmark().report();
   }
 }
 
 // S i e v e
 class SieveBenchmark extends BenchmarkBase {
   const SieveBenchmark() : super("Sieve");
 
   static int sieve(int size) {
     int primeCount = 0;
-    List<bool> flags = new List<bool>.fixedLength(size + 1);
+    List<bool> flags = new List<bool>(size + 1);
     for (int i = 1; i < size; i++) flags[i] = true;
     for (int i = 2; i < size; i++) {
       if (flags[i]) {
         primeCount++;
         for (int k = i + 1; k <= size; k += i)
           flags[k - 1] = false;
       }
     }
     return primeCount;
   }
@@ skipping 37 matching lines @@
       for (int k = n - 1; k >= 1; k--) {
         swap(n, k, list);
         doPermute(n - 1, list);
         swap(n, k, list);
       }
     }
   }
 
   int permute(int size) {
     permuteCount = 0;
-    List<int> list = new List<int>.fixedLength(size);
+    List<int> list = new List<int>(size);
     for (int i = 1; i < size; i++) list[i] = i - 1;
     doPermute(size - 1, list);
     return permuteCount;
   }
 }
 
 class PermuteBenchmark extends BenchmarkBase {
   const PermuteBenchmark() : super("Permute");
 
   void warmup() {
@@ skipping 42 matching lines @@
           }
         } else {
           q = true;
         }
       }
     }
     return q;
   }
 
   static void queens() {
-    List<bool> a = new List<bool>.fixedLength(9);
-    List<bool> b = new List<bool>.fixedLength(17);
-    List<bool> c = new List<bool>.fixedLength(15);
-    List<int> x = new List<int>.fixedLength(9);
+    List<bool> a = new List<bool>(9);
+    List<bool> b = new List<bool>(17);
+    List<bool> c = new List<bool>(15);
+    List<int> x = new List<int>(9);
     b[1] = false;
     for (int i = -7; i <= 16; i++) {
       if ((i >= 1) && (i <= 8)) a[i] = true;
       if (i >= 2) b[i] = true;
       if (i <= 7) c[i + 7] = true;
     }
 
     if (!tryQueens(1, b, a, c, x))
       Error.error("Error in queens");
   }
@@ skipping 85 matching lines @@
 }
 
 //
 class SortData {
   List<int> list;
   int min;
   int max;
 
   SortData(int length) {
     Random r = new Random();
-    list = new List<int>.fixedLength(length);
+    list = new List<int>(length);
     for (int i = 0; i < length; i++) list[i] = r.random();
 
     int min, max;
     min = max = list[0];
     for (int i = 0; i < length; i++) {
       int e = list[i];
       if (e > max) max = e;
       if (e < min) min = e;
     }
 
@@ skipping 890 matching lines @@
       var idx = i;
       remote.call(sentObject).then(expectAsync1((var receivedObject) {
         MessageTest.VerifyObject(idx, receivedObject);
       }));
     }
 
     // Send recursive objects and receive them back.
     List local_list1 = ["Hello", "World", "Hello", 0xffffffffff];
     List local_list2 = [null, local_list1, local_list1 ];
     List local_list3 = [local_list2, 2.0, true, false, 0xffffffffff];
-    List sendObject = new List.fixedLength(5);
+    List sendObject = new List(5);
     sendObject[0] = local_list1;
     sendObject[1] = sendObject;
     sendObject[2] = local_list2;
     sendObject[3] = sendObject;
     sendObject[4] = local_list3;
     remote.call(sendObject).then((var replyObject) {
       Expect.equals(true, sendObject is List);
       Expect.equals(true, replyObject is List);
       Expect.equals(sendObject.length, replyObject.length);
       Expect.equals(true, identical(replyObject[1], replyObject));
@@ skipping 103 matching lines @@
     }));
     for (int i = 0; i < Math.min(ISOLATES, N); i++) state.startClient(i);
   });
 }
 
 
 class MandelbrotState {
 
   MandelbrotState() {
     _result = new List<List<int>>(N);
-    _lineProcessedBy = new List<LineProcessorClient>.fixedLength(N);
+    _lineProcessedBy = new List<LineProcessorClient>(N);
     _sent = 0;
     _missing = N;
     _validated = new Completer<bool>();
   }
 
   void startClient(int id) {
     assert(_sent < N);
     final client = new LineProcessorClient(this, id);
     client.processLine(_sent++);
   }
@@ skipping 59 matching lines @@
   }
 
   MandelbrotState _state;
   int _id;
   SendPort _port;
 }
 
 List<int> processLine(int y) {
   double inverseN = 2.0 / N;
   double Civ = y * inverseN - 1.0;
-  List<int> result = new List<int>.fixedLength(N);
+  List<int> result = new List<int>(N);
   for (int x = 0; x < N; x++) {
     double Crv = x * inverseN - 1.5;
 
     double Zrv = Crv;
     double Ziv = Civ;
 
     double Trv = Crv * Crv;
     double Tiv = Civ * Civ;
 
     int i = 49;
@@ skipping 13 matching lines @@
 void processLines() {
   port.receive((message, SendPort replyTo) {
     if (message == TERMINATION_MESSAGE) {
       assert(replyTo == null);
       port.close();
     } else {
       replyTo.send(processLine(message), null);
     }
   });
 }