anchor.diff:      return next;
     }
   
  -  /**
  -   * Parse a list of type arguments, starting at the [startToken], without
  -   * actually creating a type argument list or changing the current token.
  -   * Return the token following the type argument list that was parsed, or
  -   * `null` if the given token is not the first token in a valid type argument
  -   * list.
  -   *
  -   * This method must be kept in sync with [parseTypeArgumentList].
  -   *
  -   *     typeArguments ::=
  -   *         '<' typeList '>'
  -   *
  -   *     typeList ::=
  -   *         type (',' type)*
  -   */
  +  /// Parse a list of type arguments, starting at the [startToken], without
  +  /// actually creating a type argument list or changing the current token.
  +  /// Return the token following the type argument list that was parsed, or
  +  /// `null` if the given token is not the first token in a valid type argument
  +  /// list.
  +  ///
  +  /// This method must be kept in sync with [parseTypeArgumentList].
  +  ///
  +  ///     typeArguments ::=
  +  ///         '<' typeList '>'
  +  ///
  +  ///     typeList ::=
  +  ///         type (',' type)*
     Token skipTypeArgumentList(Token startToken) {
       Token token = startToken;
       if (!_tokenMatches(token, TokenType.LT)) {
  
positive.code:     return type;
    }
  
    /**
     * Parse a list of type arguments. Return the type argument list that was
     * parsed.
     *
     * This method assumes that the current token matches `TokenType.LT`.
     *
     *     typeArguments ::=
     *         '<' typeList '>'
     *
     *     typeList ::=
     *         type (',' type)*
     */
    TypeArgumentList parseTypeArgumentList() {
      Token leftBracket = getAndAdvance();
      List<TypeAnnotation> arguments = <TypeAnnotation>[
  
negative.code:     return false;
    }
  
    /// Return a synthetic token representing the given [keyword].
    Token _createSyntheticKeyword(Keyword keyword) =>
        _injectToken(new SyntheticKeywordToken(keyword, _currentToken.offset));
  
    /// Return a synthetic token with the given [type].
    Token _createSyntheticToken(TokenType type) =>
        _injectToken(new StringToken(type, "", _currentToken.offset));
  
    /// Create and return a new token with the given [type]. The token will
    /// replace the first portion of the given [token], so it will have the same
    /// offset and will have any comments that might have preceeded the token.
    Token _createToken(Token token, TokenType type, {bool isBegin: false}) {
      CommentToken comments = token.precedingComments;
      if (comments == null) {
  