Analyzer snapshot.

pkg/analyzer/lib/src/generated/parser.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.parser;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
@@ skipping 3429 matching lines @@
    *          not given
    * @return the class declaration that was parsed
    */
   CompilationUnitMember parseClassDeclaration(CommentAndMetadata commentAndMetadata, Token abstractKeyword) {
     Token keyword = expect(Keyword.CLASS);
     if (matchesIdentifier()) {
       Token next = peek();
       if (matches4(next, TokenType.LT)) {
         next = skipTypeParameterList(next);
         if (next != null && matches4(next, TokenType.EQ)) {
-          return parseClassTypeAlias(commentAndMetadata, keyword);
+          return parseClassTypeAlias(commentAndMetadata, abstractKeyword, keyword);
         }
       } else if (matches4(next, TokenType.EQ)) {
-        return parseClassTypeAlias(commentAndMetadata, keyword);
+        return parseClassTypeAlias(commentAndMetadata, abstractKeyword, keyword);
       }
     }
     SimpleIdentifier name = parseSimpleIdentifier();
     String className = name.name;
     TypeParameterList typeParameters = null;
     if (matches5(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
     ExtendsClause extendsClause = null;
     WithClause withClause = null;
@@ skipping 97 matching lines @@
    *
    * <pre>
    * classTypeAlias ::=
    *     identifier typeParameters? '=' 'abstract'? mixinApplication
    *
    * mixinApplication ::=
    *     type withClause implementsClause? ';'
    * </pre>
    *
    * @param commentAndMetadata the metadata to be associated with the member
-   * @param keyword the token representing the 'typedef' keyword
+   * @param abstractKeyword the token representing the 'abstract' keyword
+   * @param classKeyword the token representing the 'class' keyword
    * @return the class type alias that was parsed
    */
-  ClassTypeAlias parseClassTypeAlias(CommentAndMetadata commentAndMetadata, Token keyword) {
+  ClassTypeAlias parseClassTypeAlias(CommentAndMetadata commentAndMetadata, Token abstractKeyword, Token classKeyword) {
     SimpleIdentifier className = parseSimpleIdentifier();
     TypeParameterList typeParameters = null;
     if (matches5(TokenType.LT)) {
       typeParameters = parseTypeParameterList();
     }
     Token equals = expect2(TokenType.EQ);
-    Token abstractKeyword = null;
     if (matches(Keyword.ABSTRACT)) {
       abstractKeyword = andAdvance;
     }
     TypeName superclass = parseTypeName();
     WithClause withClause = null;
     if (matches(Keyword.WITH)) {
       withClause = parseWithClause();
     }
     ImplementsClause implementsClause = null;
     if (matches(Keyword.IMPLEMENTS)) {
       implementsClause = parseImplementsClause();
     }
     Token semicolon;
     if (matches5(TokenType.SEMICOLON)) {
       semicolon = andAdvance;
     } else {
       if (matches5(TokenType.OPEN_CURLY_BRACKET)) {
         reportError10(ParserErrorCode.EXPECTED_TOKEN, [TokenType.SEMICOLON.lexeme]);
         Token leftBracket = andAdvance;
         parseClassMembers(className.name, getEndToken(leftBracket));
         expect2(TokenType.CLOSE_CURLY_BRACKET);
       } else {
         reportError11(ParserErrorCode.EXPECTED_TOKEN, _currentToken.previous, [TokenType.SEMICOLON.lexeme]);
       }
       semicolon = createSyntheticToken2(TokenType.SEMICOLON);
     }
-    return new ClassTypeAlias(commentAndMetadata.comment, commentAndMetadata.metadata, keyword, className, typeParameters, equals, abstractKeyword, superclass, withClause, implementsClause, semicolon);
+    return new ClassTypeAlias(commentAndMetadata.comment, commentAndMetadata.metadata, classKeyword, className, typeParameters, equals, abstractKeyword, superclass, withClause, implementsClause, semicolon);
   }
 
   /**
    * Parse a list of combinators in a directive.
    *
    * <pre>
    * combinator ::=
    *     'show' identifier (',' identifier)*
    *   | 'hide' identifier (',' identifier)*
    * </pre>
@@ skipping 167 matching lines @@
     if (matches(Keyword.CLASS)) {
       return parseClassDeclaration(commentAndMetadata, validateModifiersForClass(modifiers));
     } else if (matches(Keyword.TYPEDEF) && !matches4(peek(), TokenType.PERIOD) && !matches4(peek(), TokenType.LT) && !matches4(peek(), TokenType.OPEN_PAREN)) {
       validateModifiersForTypedef(modifiers);
       return parseTypeAlias(commentAndMetadata);
     }
     if (matches(Keyword.VOID)) {
       TypeName returnType = parseReturnType();
       if ((matches(Keyword.GET) || matches(Keyword.SET)) && matchesIdentifier2(peek())) {
         validateModifiersForTopLevelFunction(modifiers);
-        return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, null);
+        return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, returnType);
       } else if (matches(Keyword.OPERATOR) && isOperator(peek())) {
         reportError11(ParserErrorCode.TOP_LEVEL_OPERATOR, _currentToken, []);
         return convertToFunctionDeclaration(parseOperator(commentAndMetadata, modifiers.externalKeyword, returnType));
       } else if (matchesIdentifier() && matchesAny(peek(), [
           TokenType.OPEN_PAREN,
           TokenType.OPEN_CURLY_BRACKET,
           TokenType.FUNCTION])) {
         validateModifiersForTopLevelFunction(modifiers);
         return parseFunctionDeclaration(commentAndMetadata, modifiers.externalKeyword, returnType);
       } else {
@@ skipping 2028 matching lines @@
    * @param commentAndMetadata the metadata to be associated with the member
    * @return the type alias that was parsed
    */
   TypeAlias parseTypeAlias(CommentAndMetadata commentAndMetadata) {
     Token keyword = expect(Keyword.TYPEDEF);
     if (matchesIdentifier()) {
       Token next = peek();
       if (matches4(next, TokenType.LT)) {
         next = skipTypeParameterList(next);
         if (next != null && matches4(next, TokenType.EQ)) {
-          TypeAlias typeAlias = parseClassTypeAlias(commentAndMetadata, keyword);
+          TypeAlias typeAlias = parseClassTypeAlias(commentAndMetadata, null, keyword);
           reportError11(ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword, []);
           return typeAlias;
         }
       } else if (matches4(next, TokenType.EQ)) {
-        TypeAlias typeAlias = parseClassTypeAlias(commentAndMetadata, keyword);
+        TypeAlias typeAlias = parseClassTypeAlias(commentAndMetadata, null, keyword);
         reportError11(ParserErrorCode.DEPRECATED_CLASS_TYPE_ALIAS, keyword, []);
         return typeAlias;
       }
     }
     return parseFunctionTypeAlias(commentAndMetadata, keyword);
   }
 
   /**
    * Parse a unary expression.
    *
@@ skipping 1472 matching lines @@
 
   /**
    * The template used to create the message to be displayed for this error.
    */
   String _message;
 
   /**
    * The template used to create the correction to be displayed for this error, or `null` if
    * there is no correction information for this error.
    */
-  String correction8;
+  String correction9;
 
   /**
    * Initialize a newly created error code to have the given severity and message.
    *
    * @param severity the severity of the error
    * @param message the message template used to create the message to be displayed for the error
    */
   ParserErrorCode.con1(String name, int ordinal, ErrorSeverity severity, String message) : super(name, ordinal) {
     this._severity = severity;
     this._message = message;
   }
 
   /**
    * Initialize a newly created error code to have the given severity, message and correction.
    *
    * @param severity the severity of the error
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
   ParserErrorCode.con2(String name, int ordinal, ErrorSeverity severity, String message, String correction) : super(name, ordinal) {
     this._severity = severity;
     this._message = message;
-    this.correction8 = correction;
+    this.correction9 = correction;
   }
 
   /**
    * Initialize a newly created error code to have the given message and a severity of ERROR.
    *
    * @param message the message template used to create the message to be displayed for the error
    */
   ParserErrorCode.con3(String name, int ordinal, String message) : this.con1(name, ordinal, ErrorSeverity.ERROR, message);
 
-  String get correction => correction8;
+  String get correction => correction9;
 
   ErrorSeverity get errorSeverity => _severity;
 
   String get message => _message;
 
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }
 
 /**
  * Instances of the class `ResolutionCopier` copies resolution information from one AST
@@ skipping 1909 matching lines @@
       if ("\n" == separator) {
         _writer.print("\n");
         indent();
       } else if (i > 0) {
         _writer.print(separator);
       }
       _writer.print(tokens[i].lexeme);
     }
   }
 }