New analyzer snapshot.

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 'java_core.dart';
@@ skipping 2541 matching lines @@
    *
    * @return the type argument list that was parsed
    */
   TypeArgumentList parseTypeArgumentList() {
     Token leftBracket = _expect(TokenType.LT);
     List<TypeName> arguments = new List<TypeName>();
     arguments.add(parseTypeName());
     while (_optional(TokenType.COMMA)) {
       arguments.add(parseTypeName());
     }
-    Token rightBracket = _expect(TokenType.GT);
+    Token rightBracket = _expectGt();
     return new TypeArgumentList(leftBracket, arguments, rightBracket);
   }
 
   /**
    * Parse a type name.
    *
    * <pre>
    * type ::=
    *     qualified typeArguments?
    * </pre>
@@ skipping 49 matching lines @@
    *
    * @return the list of type parameters that were parsed
    */
   TypeParameterList parseTypeParameterList() {
     Token leftBracket = _expect(TokenType.LT);
     List<TypeParameter> typeParameters = new List<TypeParameter>();
     typeParameters.add(parseTypeParameter());
     while (_optional(TokenType.COMMA)) {
       typeParameters.add(parseTypeParameter());
     }
-    Token rightBracket = _expect(TokenType.GT);
+    Token rightBracket = _expectGt();
     return new TypeParameterList(leftBracket, typeParameters, rightBracket);
   }
 
   /**
    * Parse a with clause.
    *
    * <pre>
    * withClause ::=
    *     'with' typeName (',' typeName)*
    * </pre>
@@ skipping 193 matching lines @@
    * @param expression the expression being checked
    */
   void _ensureAssignable(Expression expression) {
     if (expression != null && !expression.isAssignable) {
       _reportErrorForCurrentToken(ParserErrorCode.ILLEGAL_ASSIGNMENT_TO_NON_ASSIGNABLE, []);
     }
   }
 
   /**
    * If the current token has the expected type, return it after advancing to the next token.
-   * Otherwise report an error and return the current token without advancing.
+   * Otherwise report an error and return the current token without advancing. Note that the method
+   * [expectGt] should be used if the argument to this method would be [TokenType#GT]
+   * .
    *
    * @param type the type of token that is expected
    * @return the token that matched the given type
    */
   Token _expect(TokenType type) {
     if (_matches(type)) {
       return andAdvance;
     }
     // Remove uses of this method in favor of matches?
     // Pass in the error code to use to report the error?
     if (identical(type, TokenType.SEMICOLON)) {
       _reportErrorForToken(ParserErrorCode.EXPECTED_TOKEN, _currentToken.previous, [type.lexeme]);
     } else {
       _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_TOKEN, [type.lexeme]);
     }
     return _currentToken;
   }
 
   /**
+   * If the current token has the type [TokenType#GT], return it after advancing to the next
+   * token. Otherwise report an error and return the current token without advancing.
+   *
+   * @return the token that matched the given type
+   */
+  Token _expectGt() {
+    if (_matchesGt()) {
+      return andAdvance;
+    }
+    _reportErrorForCurrentToken(ParserErrorCode.EXPECTED_TOKEN, [TokenType.GT.lexeme]);
+    return _currentToken;
+  }
+
+  /**
    * If the current token is a keyword matching the given string, return it after advancing to the
    * next token. Otherwise report an error and return the current token without advancing.
    *
    * @param keyword the keyword that is expected
    * @return the token that matched the given type
    */
   Token _expectKeyword(Keyword keyword) {
     if (_matchesKeyword(keyword)) {
       return andAdvance;
     }
@@ skipping 379 matching lines @@
 
   /**
    * 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 this method, unlike
-   * other variants, will modify the token stream if possible to match a wider range of tokens. In
-   * particular, if we are attempting to match a '>' and the next token is either a '>>' or '>>>',
-   * the token stream will be re-written and `true` will be returned.
+   * 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
+   * [TokenType#GT].
    *
    * @param type the type of token that can optionally appear in the current location
    * @return `true` if the current token has the given type
    */
-  bool _matches(TokenType type) {
+  bool _matches(TokenType type) => identical(_currentToken.type, type);
+
+  /**
+   * Return `true` if the current token has a type of [TokenType#GT]. Note that this
+   * method, unlike other variants, will modify the token stream if possible to match desired type.
+   * In particular, if the next token is either a '>>' or '>>>', the token stream will be re-written
+   * and `true` will be returned.
+   *
+   * @return `true` if the current token has a type of [TokenType#GT]
+   */
+  bool _matchesGt() {
     TokenType currentType = _currentToken.type;
-    if (currentType != type) {
-      if (identical(type, TokenType.GT)) {
-        if (identical(currentType, TokenType.GT_GT)) {
-          int offset = _currentToken.offset;
-          Token first = new Token(TokenType.GT, offset);
-          Token second = new Token(TokenType.GT, offset + 1);
-          second.setNext(_currentToken.next);
-          first.setNext(second);
-          _currentToken.previous.setNext(first);
-          _currentToken = first;
-          return true;
-        } else if (identical(currentType, TokenType.GT_EQ)) {
-          int offset = _currentToken.offset;
-          Token first = new Token(TokenType.GT, offset);
-          Token second = new Token(TokenType.EQ, offset + 1);
-          second.setNext(_currentToken.next);
-          first.setNext(second);
-          _currentToken.previous.setNext(first);
-          _currentToken = first;
-          return true;
-        } else if (identical(currentType, TokenType.GT_GT_EQ)) {
-          int offset = _currentToken.offset;
-          Token first = new Token(TokenType.GT, offset);
-          Token second = new Token(TokenType.GT, offset + 1);
-          Token third = new Token(TokenType.EQ, offset + 2);
-          third.setNext(_currentToken.next);
-          second.setNext(third);
-          first.setNext(second);
-          _currentToken.previous.setNext(first);
-          _currentToken = first;
-          return true;
-        }
-      }
-      return false;
+    if (identical(currentType, TokenType.GT)) {
+      return true;
+    } else if (identical(currentType, TokenType.GT_GT)) {
+      int offset = _currentToken.offset;
+      Token first = new Token(TokenType.GT, offset);
+      Token second = new Token(TokenType.GT, offset + 1);
+      second.setNext(_currentToken.next);
+      first.setNext(second);
+      _currentToken.previous.setNext(first);
+      _currentToken = first;
+      return true;
+    } else if (identical(currentType, TokenType.GT_EQ)) {
+      int offset = _currentToken.offset;
+      Token first = new Token(TokenType.GT, offset);
+      Token second = new Token(TokenType.EQ, offset + 1);
+      second.setNext(_currentToken.next);
+      first.setNext(second);
+      _currentToken.previous.setNext(first);
+      _currentToken = first;
+      return true;
+    } else if (identical(currentType, TokenType.GT_GT_EQ)) {
+      int offset = _currentToken.offset;
+      Token first = new Token(TokenType.GT, offset);
+      Token second = new Token(TokenType.GT, offset + 1);
+      Token third = new Token(TokenType.EQ, offset + 2);
+      third.setNext(_currentToken.next);
+      second.setNext(third);
+      first.setNext(second);
+      _currentToken.previous.setNext(first);
+      _currentToken = first;
+      return true;
     }
-    return true;
+    return false;
   }
 
   /**
    * Return `true` if the current token is a valid identifier. Valid identifiers include
    * built-in identifiers (pseudo-keywords).
    *
    * @return `true` if the current token is a valid identifier
    */
   bool _matchesIdentifier() => _tokenMatchesIdentifier(_currentToken);
 
   /**
    * Return `true` if the current token matches the given keyword.
    *
    * @param keyword the keyword that can optionally appear in the current location
    * @return `true` if the current token matches the given keyword
    */
   bool _matchesKeyword(Keyword keyword) => _tokenMatchesKeyword(_currentToken, keyword);
 
   /**
    * Return `true` if the current token matches the given identifier.
    *
    * @param identifier the identifier that can optionally appear in the current location
    * @return `true` if the current token matches the given identifier
    */
   bool _matchesString(String identifier) => identical(_currentToken.type, TokenType.IDENTIFIER) && _currentToken.lexeme == identifier;
 
   /**
    * If the current token has the given type, then advance to the next token and return `true`
-   * . Otherwise, return `false` without advancing.
+   * . Otherwise, return `false` without advancing. This method should not be invoked with an
+   * argument value of [TokenType#GT].
    *
    * @param type the type of token that can optionally appear in the current location
    * @return `true` if the current token has the given type
    */
   bool _optional(TokenType type) {
     if (_matches(type)) {
       _advance();
       return true;
     }
     return false;
@@ skipping 5440 matching lines @@
   'appendScalarValue_5': new MethodTrampoline(5, (Parser target, arg0, arg1, arg2, arg3, arg4) => target._appendScalarValue(arg0, arg1, arg2, arg3, arg4)),
   'computeStringValue_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target._computeStringValue(arg0, arg1, arg2)),
   'convertToFunctionDeclaration_1': new MethodTrampoline(1, (Parser target, arg0) => target._convertToFunctionDeclaration(arg0)),
   'couldBeStartOfCompilationUnitMember_0': new MethodTrampoline(0, (Parser target) => target._couldBeStartOfCompilationUnitMember()),
   'createSyntheticIdentifier_0': new MethodTrampoline(0, (Parser target) => target._createSyntheticIdentifier()),
   'createSyntheticKeyword_1': new MethodTrampoline(1, (Parser target, arg0) => target._createSyntheticKeyword(arg0)),
   'createSyntheticStringLiteral_0': new MethodTrampoline(0, (Parser target) => target._createSyntheticStringLiteral()),
   'createSyntheticToken_1': new MethodTrampoline(1, (Parser target, arg0) => target._createSyntheticToken(arg0)),
   'ensureAssignable_1': new MethodTrampoline(1, (Parser target, arg0) => target._ensureAssignable(arg0)),
   'expect_1': new MethodTrampoline(1, (Parser target, arg0) => target._expect(arg0)),
+  'expectGt_0': new MethodTrampoline(0, (Parser target) => target._expectGt()),
   'expectKeyword_1': new MethodTrampoline(1, (Parser target, arg0) => target._expectKeyword(arg0)),
   'expectSemicolon_0': new MethodTrampoline(0, (Parser target) => target._expectSemicolon()),
   'findRange_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target._findRange(arg0, arg1)),
   'getCodeBlockRanges_1': new MethodTrampoline(1, (Parser target, arg0) => target._getCodeBlockRanges(arg0)),
   '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()),
   'parseArgumentDefinitionTest_0': new MethodTrampoline(0, (Parser target) => target._parseArgumentDefinitionTest()),
   'parseAssertStatement_0': new MethodTrampoline(0, (Parser target) => target._parseAssertStatement()),
   'parseAssignableExpression_1': new MethodTrampoline(1, (Parser target, arg0) => target._parseAssignableExpression(arg0)),
   'parseAssignableSelector_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target._parseAssignableSelector(arg0, arg1)),
   'parseBitwiseAndExpression_0': new MethodTrampoline(0, (Parser target) => target._parseBitwiseAndExpression()),
@@ skipping 136 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");
     }
   }
 }