Generate unique names less aggressively.

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 'java_engine.dart';
 import 'source.dart';
 import 'error.dart';
@@ skipping 18 matching lines @@
    * 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) {
+  static KeywordState computeKeywordStateTable(int start, List<String> strings, int offset, int length2) {
     List<KeywordState> result = new List<KeywordState>(26);
-    assert(length12 != 0);
+    assert(length2 != 0);
     int chunk = 0x0;
     int chunkStart = -1;
     bool isLeaf = false;
-    for (int i = offset; i < offset + length12; i++) {
+    for (int i = offset; i < offset + length2; i++) {
       if (strings[i].length == start) {
         isLeaf = true;
       }
       if (strings[i].length > start) {
         int c = strings[i].codeUnitAt(start);
         if (chunk != c) {
           if (chunkStart != -1) {
             result[chunk - 0x61] = computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart);
           }
           chunkStart = i;
           chunk = c;
         }
       }
     }
     if (chunkStart != -1) {
       assert(result[chunk - 0x61] == null);
-      result[chunk - 0x61] = computeKeywordStateTable(start + 1, strings, chunkStart, offset + length12 - chunkStart);
+      result[chunk - 0x61] = computeKeywordStateTable(start + 1, strings, chunkStart, offset + length2 - chunkStart);
     } else {
-      assert(length12 == 1);
+      assert(length2 == 1);
       return new KeywordState(_EMPTY_TABLE, strings[offset]);
     }
     if (isLeaf) {
       return new KeywordState(result, strings[offset]);
     } else {
       return new KeywordState(result, null);
     }
   }
   /**
    * Create the initial state in the state machine.
@@ skipping 365 matching lines @@
     _groupingStack.add(token);
   }
   void appendCommentToken(TokenType type, String value) {
     if (_firstComment == null) {
       _firstComment = new StringToken(type, value, _tokenStart);
       _lastComment = _firstComment;
     } else {
       _lastComment = _lastComment.setNext(new StringToken(type, value, _tokenStart));
     }
   }
-  void appendEndToken(TokenType type42, TokenType beginType) {
+  void appendEndToken(TokenType type2, TokenType beginType) {
     Token token;
     if (_firstComment == null) {
-      token = new Token(type42, _tokenStart);
+      token = new Token(type2, _tokenStart);
     } else {
-      token = new TokenWithComment(type42, _tokenStart, _firstComment);
+      token = new TokenWithComment(type2, _tokenStart, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
     _tail = _tail.setNext(token);
     int last = _groupingStack.length - 1;
     if (last >= 0) {
       BeginToken begin = _groupingStack[last];
       if (identical(begin.type, beginType)) {
         begin.endToken = token;
         _groupingStack.removeAt(last);
@@ skipping 72 matching lines @@
       }
       recordStartOfLine();
       return next;
     } else if (next == 0xA) {
       recordStartOfLine();
       return advance();
     } else if (next == 0x9 || next == 0x20) {
       return advance();
     }
     if (next == 0x72) {
-      int peek3 = peek();
-      if (peek3 == 0x22 || peek3 == 0x27) {
+      int peek2 = peek();
+      if (peek2 == 0x22 || peek2 == 0x27) {
         int start = offset;
         return tokenizeString(advance(), start, true);
       }
     }
     if (0x61 <= next && next <= 0x7A) {
       return tokenizeKeywordOrIdentifier(next, true);
     }
     if ((0x41 <= next && next <= 0x5A) || next == 0x5F || next == 0x24) {
       return tokenizeIdentifier(next, offset, true);
     }
@@ skipping 861 matching lines @@
    */
   Token setNextWithoutSettingPrevious(Token token) {
     _next = token;
     return token;
   }
   /**
    * Set the offset from the beginning of the file to the first character in the token to the given
    * offset.
    * @param offset the offset from the beginning of the file to the first character in the token
    */
-  void set offset(int offset4) {
-    this._offset = offset4;
+  void set offset(int offset2) {
+    this._offset = offset2;
   }
   String toString() => lexeme;
   /**
    * Return the value of this token. For keyword tokens, this is the keyword associated with the
    * token, for other tokens it is the lexeme associated with the token.
    * @return the value of this token
    */
   Object value() => _type.lexeme;
   /**
    * Set the previous token in the token stream to the given token.
    * @param previous the previous token in the token stream
    */
-  void set previous(Token previous3) {
-    this._previous = previous3;
+  void set previous(Token previous2) {
+    this._previous = previous2;
   }
 }
 /**
  * Instances of the class {@code StringScanner} implement a scanner that reads from a string. The
  * scanning logic is in the superclass.
  * @coverage dart.engine.parser
  */
 class StringScanner extends AbstractScanner {
   /**
    * The offset from the beginning of the file to the beginning of the source being scanned.
@@ skipping 445 matching lines @@
    * @return {@code true} if this token type represents an operator that can be defined by users
    */
   bool isUserDefinableOperator() => identical(_lexeme, "==") || identical(_lexeme, "~") || identical(_lexeme, "[]") || identical(_lexeme, "[]=") || identical(_lexeme, "*") || identical(_lexeme, "/") || identical(_lexeme, "%") || identical(_lexeme, "~/") || identical(_lexeme, "+") || identical(_lexeme, "-") || identical(_lexeme, "<<") || identical(_lexeme, ">>") || identical(_lexeme, ">=") || identical(_lexeme, ">") || identical(_lexeme, "<=") || identical(_lexeme, "<") || identical(_lexeme, "&") || identical(_lexeme, "^") || identical(_lexeme, "|");
   int compareTo(TokenType other) => __ordinal - other.__ordinal;
   String toString() => __name;
 }
 class TokenType_EOF extends TokenType {
   TokenType_EOF(String ___name, int ___ordinal, TokenClass arg0, String arg1) : super.con2(___name, ___ordinal, arg0, arg1);
   String toString() => "-eof-";
 }