Improved 'has' properties translation.

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 1679 matching lines @@
       reportErrorForToken(ParserErrorCode.EXPECTED_CLASS_MEMBER, _currentToken, []);
       if (commentAndMetadata.comment != null || !commentAndMetadata.metadata.isEmpty) {
         //
         // We appear to have found an incomplete declaration at the end of the class. At this point
         // it consists of a metadata, which we don't want to loose, so we'll treat it as a method
         // declaration with a missing name, parameters and empty body.
         //
         return new MethodDeclaration(commentAndMetadata.comment, commentAndMetadata.metadata, null, null, null, null, null, createSyntheticIdentifier(), new FormalParameterList(null, new List<FormalParameter>(), null, null, null), new EmptyFunctionBody(createSyntheticToken(TokenType.SEMICOLON)));
       }
       return null;
-    } else if (tokenMatches(peek(), TokenType.PERIOD) && tokenMatchesIdentifier(peek2(2)) && tokenMatches(peek2(3), TokenType.OPEN_PAREN)) {
+    } else if (tokenMatches(peek(), TokenType.PERIOD) && tokenMatchesIdentifier(peekAt(2)) && tokenMatches(peekAt(3), TokenType.OPEN_PAREN)) {
       return parseConstructor(commentAndMetadata, modifiers.externalKeyword, validateModifiersForConstructor(modifiers), modifiers.factoryKeyword, parseSimpleIdentifier(), andAdvance, parseSimpleIdentifier(), parseFormalParameterList());
     } else if (tokenMatches(peek(), TokenType.OPEN_PAREN)) {
       SimpleIdentifier methodName = parseSimpleIdentifier();
       FormalParameterList parameters = parseFormalParameterList();
       if (matches(TokenType.COLON) || modifiers.factoryKeyword != null || methodName.name == className) {
         return parseConstructor(commentAndMetadata, modifiers.externalKeyword, validateModifiersForConstructor(modifiers), modifiers.factoryKeyword, methodName, null, null, parameters);
       }
       validateModifiersForGetterOrSetterOrMethod(modifiers);
       validateFormalParameterList(parameters);
       return parseMethodDeclarationAfterParameters(commentAndMetadata, modifiers.externalKeyword, modifiers.staticKeyword, null, methodName, parameters);
@@ skipping 1178 matching lines @@
 
   /**
    * Return `true` if the current token is the first token of a return type that is followed
    * by an identifier, possibly followed by a list of type parameters, followed by a
    * left-parenthesis. This is used by parseTypeAlias to determine whether or not to parse a return
    * type.
    *
    * @return `true` if we can successfully parse the rest of a type alias if we first parse a
    *         return type.
    */
-  bool hasReturnTypeInTypeAlias() {
+  bool get hasReturnTypeInTypeAlias {
     Token next = skipReturnType(_currentToken);
     if (next == null) {
       return false;
     }
     return tokenMatchesIdentifier(next);
   }
 
   /**
    * Inject the given token into the token stream immediately before the current token.
    *
@@ skipping 1158 matching lines @@
     Token separator = null;
     List<ConstructorInitializer> initializers = null;
     if (matches(TokenType.COLON)) {
       separator = andAdvance;
       initializers = new List<ConstructorInitializer>();
       do {
         if (matchesKeyword(Keyword.THIS)) {
           if (tokenMatches(peek(), TokenType.OPEN_PAREN)) {
             bodyAllowed = false;
             initializers.add(parseRedirectingConstructorInvocation());
-          } else if (tokenMatches(peek(), TokenType.PERIOD) && tokenMatches(peek2(3), TokenType.OPEN_PAREN)) {
+          } else if (tokenMatches(peek(), TokenType.PERIOD) && tokenMatches(peekAt(3), TokenType.OPEN_PAREN)) {
             bodyAllowed = false;
             initializers.add(parseRedirectingConstructorInvocation());
           } else {
             initializers.add(parseConstructorFieldInitializer());
           }
         } else if (matchesKeyword(Keyword.SUPER)) {
           initializers.add(parseSuperConstructorInvocation());
         } else {
           initializers.add(parseConstructorFieldInitializer());
         }
@@ skipping 146 matching lines @@
           commentTokens.add(commentToken);
         }
       }
       commentToken = commentToken.next;
     }
     if (commentTokens.isEmpty) {
       return null;
     }
     List<Token> tokens = new List.from(commentTokens);
     List<CommentReference> references = parseCommentReferences(tokens);
-    return Comment.createDocumentationComment2(tokens, references);
+    return Comment.createDocumentationCommentWithReferences(tokens, references);
   }
 
   /**
    * Parse a do statement.
    *
    * <pre>
    * doStatement ::=
    *     'do' statement 'while' '(' expression ')' ';'
    * </pre>
    *
@@ skipping 433 matching lines @@
    * functionPrefix ::=
    *     returnType? name
    * </pre>
    *
    * @param commentAndMetadata the metadata to be associated with the member
    * @param keyword the token representing the 'typedef' keyword
    * @return the function type alias that was parsed
    */
   FunctionTypeAlias parseFunctionTypeAlias(CommentAndMetadata commentAndMetadata, Token keyword) {
     TypeName returnType = null;
-    if (hasReturnTypeInTypeAlias()) {
+    if (hasReturnTypeInTypeAlias) {
       returnType = parseReturnType();
     }
     SimpleIdentifier name = parseSimpleIdentifier();
     TypeParameterList typeParameters = null;
     if (matches(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
     if (matches(TokenType.SEMICOLON) || matches(TokenType.EOF)) {
       reportErrorForCurrentToken(ParserErrorCode.MISSING_TYPEDEF_PARAMETERS, []);
       FormalParameterList parameters = new FormalParameterList(createSyntheticToken(TokenType.OPEN_PAREN), null, null, null, createSyntheticToken(TokenType.CLOSE_PAREN));
@@ skipping 693 matching lines @@
   /**
    * Parse a return type if one is given, otherwise return `null` without advancing.
    *
    * @return the return type that was parsed
    */
   TypeName parseOptionalReturnType() {
     if (matchesKeyword(Keyword.VOID)) {
       return parseReturnType();
     } else if (matchesIdentifier() && !matchesKeyword(Keyword.GET) && !matchesKeyword(Keyword.SET) && !matchesKeyword(Keyword.OPERATOR) && (tokenMatchesIdentifier(peek()) || tokenMatches(peek(), TokenType.LT))) {
       return parseReturnType();
-    } else if (matchesIdentifier() && tokenMatches(peek(), TokenType.PERIOD) && tokenMatchesIdentifier(peek2(2)) && (tokenMatchesIdentifier(peek2(3)) || tokenMatches(peek2(3), TokenType.LT))) {
+    } else if (matchesIdentifier() && tokenMatches(peek(), TokenType.PERIOD) && tokenMatchesIdentifier(peekAt(2)) && (tokenMatchesIdentifier(peekAt(3)) || tokenMatches(peekAt(3), TokenType.LT))) {
       return parseReturnType();
     }
     return null;
   }
 
   /**
    * Parse a part or part-of directive.
    *
    * <pre>
    * partDirective ::=
@@ skipping 848 matching lines @@
       Token rightParenthesis = expect(TokenType.CLOSE_PAREN);
       Statement body = parseStatement2();
       return new WhileStatement(keyword, leftParenthesis, condition, rightParenthesis, body);
     } finally {
       _inLoop = wasInLoop;
     }
   }
 
   /**
    * Return the token that is immediately after the current token. This is equivalent to
-   * [peek].
+   * [peekAt].
    *
    * @return the token that is immediately after the current token
    */
   Token peek() => _currentToken.next;
 
   /**
    * Return the token that is the given distance after the current token.
    *
    * @param distance the number of tokens to look ahead, where `0` is the current token,
    *          `1` is the next token, etc.
    * @return the token that is the given distance after the current token
    */
-  Token peek2(int distance) {
+  Token peekAt(int distance) {
     Token token = _currentToken;
     for (int i = 0; i < distance; i++) {
       token = token.next;
     }
     return token;
   }
 
   /**
    * Report the given [AnalysisError].
    *
@@ skipping 3321 matching lines @@
    * @param suffix the suffix to be printed if there is a node to visit
    * @param node the node to be visited
    */
   void visitTokenWithSuffix(Token token, String suffix) {
     if (token != null) {
       _writer.print(token.lexeme);
       _writer.print(suffix);
     }
   }
 }