Code clean-up and minor bug fix

pkg/analyzer/lib/src/generated/parser.dart

 // Copyright (c) 2014, 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.
 
 // 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.parser;
 
 import 'dart:collection';
@@ skipping 3407 matching lines @@
       return true;
     } else if (startToken.next != token) {
       // The type is more than a simple identifier, so it should be assumed to
       // be a type name.
       return true;
     }
     return false;
   }
 
   /**
-   * Compare the given tokens to find the token that appears first in the source being parsed. That
-   * is, return the left-most of all of the tokens. The arguments are allowed to be `null`.
-   * Return the token with the smallest offset, or `null` if there are no arguments or if all
-   * of the arguments are `null`.
-   *
-   * @param tokens the tokens being compared
-   * @return the token with the smallest offset
-   */
-  Token _lexicallyFirst(List<Token> tokens) {
-    Token first = null;
-    int firstOffset = 2147483647;
-    for (Token token in tokens) {
-      if (token != null) {
-        int offset = token.offset;
-        if (offset < firstOffset) {
-          first = token;
-          firstOffset = offset;
-        }
-      }
-    }
-    return first;
-  }
-
-  /**
    * Increments the error reporting lock level. If level is more than `0`, then
    * [reportError] wont report any error.
    */
   void _lockErrorListener() {
     _errorListenerLock++;
   }
 
   /**
    * Return `true` if the current token has the given type. Note that the method
    * [_matchesGt] should be used if the argument to this method would be
@@ skipping 4217 matching lines @@
     } else if (finalKeyword != null) {
       if (varKeyword != null) {
         _reportErrorForToken(ParserErrorCode.FINAL_AND_VAR, varKeyword);
       }
       if (staticKeyword != null && finalKeyword.offset < staticKeyword.offset) {
         _reportErrorForToken(ParserErrorCode.STATIC_AFTER_FINAL, staticKeyword);
       }
     } else if (varKeyword != null && staticKeyword != null && varKeyword.offset < staticKeyword.offset) {
       _reportErrorForToken(ParserErrorCode.STATIC_AFTER_VAR, staticKeyword);
     }
-    return _lexicallyFirst([constKeyword, finalKeyword, varKeyword]);
+    return Token.lexicallyFirst([constKeyword, finalKeyword, varKeyword]);
   }
 
   /**
    * Validate that the given set of modifiers is appropriate for a local function.
    *
    * @param modifiers the modifiers being validated
    */
   void _validateModifiersForFunctionDeclarationStatement(Modifiers modifiers) {
     if (modifiers.abstractKeyword != null || modifiers.constKeyword != null || modifiers.externalKeyword != null || modifiers.factoryKeyword != null || modifiers.finalKeyword != null || modifiers.staticKeyword != null || modifiers.varKeyword != null) {
       _reportErrorForCurrentToken(ParserErrorCode.LOCAL_FUNCTION_DECLARATION_MODIFIER);
@@ skipping 112 matching lines @@
         _reportErrorForToken(ParserErrorCode.CONST_AND_FINAL, finalKeyword);
       }
       if (varKeyword != null) {
         _reportErrorForToken(ParserErrorCode.CONST_AND_VAR, varKeyword);
       }
     } else if (finalKeyword != null) {
       if (varKeyword != null) {
         _reportErrorForToken(ParserErrorCode.FINAL_AND_VAR, varKeyword);
       }
     }
-    return _lexicallyFirst([constKeyword, finalKeyword, varKeyword]);
+    return Token.lexicallyFirst([constKeyword, finalKeyword, varKeyword]);
   }
 
   /**
    * Validate that the given set of modifiers is appropriate for a class and return the 'abstract'
    * keyword if there is one.
    *
    * @param modifiers the modifiers being validated
    */
   void _validateModifiersForTypedef(Modifiers modifiers) {
     _validateModifiersForTopLevelDeclaration(modifiers);
@@ skipping 1805 matching lines @@
   'getEndToken_1': new MethodTrampoline(1, (Parser target, arg0) => target._getEndToken(arg0)),
   'injectToken_1': new MethodTrampoline(1, (Parser target, arg0) => target._injectToken(arg0)),
   'isFunctionDeclaration_0': new MethodTrampoline(0, (Parser target) => target._isFunctionDeclaration()),
   'isFunctionExpression_1': new MethodTrampoline(1, (Parser target, arg0) => target._isFunctionExpression(arg0)),
   'isHexDigit_1': new MethodTrampoline(1, (Parser target, arg0) => target._isHexDigit(arg0)),
   'isInitializedVariableDeclaration_0': new MethodTrampoline(0, (Parser target) => target._isInitializedVariableDeclaration()),
   'isLinkText_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target._isLinkText(arg0, arg1)),
   'isOperator_1': new MethodTrampoline(1, (Parser target, arg0) => target._isOperator(arg0)),
   'isSwitchMember_0': new MethodTrampoline(0, (Parser target) => target._isSwitchMember()),
   'isTypedIdentifier_1': new MethodTrampoline(1, (Parser target, arg0) => target._isTypedIdentifier(arg0)),
-  'lexicallyFirst_1': new MethodTrampoline(1, (Parser target, arg0) => target._lexicallyFirst(arg0)),
   'lockErrorListener_0': new MethodTrampoline(0, (Parser target) => target._lockErrorListener()),
   'matches_1': new MethodTrampoline(1, (Parser target, arg0) => target._matches(arg0)),
   'matchesGt_0': new MethodTrampoline(0, (Parser target) => target._matchesGt()),
   'matchesIdentifier_0': new MethodTrampoline(0, (Parser target) => target._matchesIdentifier()),
   'matchesKeyword_1': new MethodTrampoline(1, (Parser target, arg0) => target._matchesKeyword(arg0)),
   'matchesString_1': new MethodTrampoline(1, (Parser target, arg0) => target._matchesString(arg0)),
   'optional_1': new MethodTrampoline(1, (Parser target, arg0) => target._optional(arg0)),
   'parseAdditiveExpression_0': new MethodTrampoline(0, (Parser target) => target._parseAdditiveExpression()),
   'parseAssertStatement_0': new MethodTrampoline(0, (Parser target) => target._parseAssertStatement()),
   'parseAssignableExpression_1': new MethodTrampoline(1, (Parser target, arg0) => target._parseAssignableExpression(arg0)),
@@ skipping 145 matching lines @@
         return trampoline(target, arguments[0], arguments[1]);
       case 3:
         return trampoline(target, arguments[0], arguments[1], arguments[2]);
       case 4:
         return trampoline(target, arguments[0], arguments[1], arguments[2], arguments[3]);
       default:
         throw new IllegalArgumentException("Not implemented for > 4 arguments");
     }
   }
 }