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

pkg/analyzer-experimental/lib/src/generated/scanner.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.scanner;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'source.dart';
 import 'error.dart';
 import 'instrumentation.dart';
@@ skipping 1753 matching lines @@
   Token get precedingComments => _precedingComment;
 }
 /**
  * Instances of the abstract class {@code KeywordState} represent a state in a state machine used to
  * scan keywords.
  */
 class KeywordState {
   /**
    * An empty transition table used by leaf states.
    */
-  static List<KeywordState> _EMPTY_TABLE = new List<KeywordState>.fixedLength(26);
+  static List<KeywordState> _EMPTY_TABLE = new List<KeywordState>(26);
   /**
    * The initial state in the state machine.
    */
   static KeywordState KEYWORD_STATE = createKeywordStateTable();
   /**
    * Create the next state in the state machine where we have already recognized the subset of
    * strings in the given array of strings starting at the given offset and having the given length.
    * All of these strings have a common prefix and the next character is at the given start index.
    * @param start the index of the character in the strings used to transition to a new state
    * @param strings an array containing all of the strings that will be recognized by the state
    * machine
    * @param offset the offset of the first string in the array that has the prefix that is assumed
    * to have been recognized by the time we reach the state being built
    * @param length the number of strings in the array that pass through the state being built
    * @return the state that was created
    */
   static KeywordState computeKeywordStateTable(int start, List<String> strings, int offset, int length12) {
-    List<KeywordState> result = new List<KeywordState>.fixedLength(26);
+    List<KeywordState> result = new List<KeywordState>(26);
     assert(length12 != 0);
     int chunk = 0x0;
     int chunkStart = -1;
     bool isLeaf = false;
     for (int i = offset; i < offset + length12; i++) {
       if (strings[i].length == start) {
         isLeaf = true;
       }
       if (strings[i].length > start) {
         int c = strings[i].codeUnitAt(start);
@@ skipping 18 matching lines @@
     } else {
       return new KeywordState(result, null);
     }
   }
   /**
    * Create the initial state in the state machine.
    * @return the state that was created
    */
   static KeywordState createKeywordStateTable() {
     List<Keyword> values2 = Keyword.values;
-    List<String> strings = new List<String>.fixedLength(values2.length);
+    List<String> strings = new List<String>(values2.length);
     for (int i = 0; i < values2.length; i++) {
       strings[i] = values2[i].syntax;
     }
     strings.sort();
     return computeKeywordStateTable(0, strings, 0, strings.length);
   }
   /**
    * A table mapping characters to the states to which those characters will transition. (The index
    * into the array is the offset from the character {@code 'a'} to the transitioning character.)
    */
@@ skipping 18 matching lines @@
    * recognized a keyword.
    * @return the keyword that was matched by reaching this state
    */
   Keyword keyword() => _keyword2;
   /**
    * Return the state that follows this state on a transition of the given character, or{@code null} if there is no valid state reachable from this state with such a transition.
    * @param c the character used to transition from this state to another state
    * @return the state that follows this state on a transition of the given character
    */
   KeywordState next(int c) => _table[c - 0x61];
-}
+}