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 1482 matching lines @@
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseCompilationUnit");
     try {
       _currentToken = token;
       return parseCompilationUnit2();
     } finally {
       instrumentation.log2(2);
     }
   }
 
   /**
+   * Parse the script tag and directives in a compilation unit, starting with the given token, until
+   * the first non-directive is encountered. The remainder of the compilation unit will not be
+   * parsed. Specifically, if there are directives later in the file, they will not be parsed.
+   *
+   * @param token the first token of the compilation unit
+   * @return the compilation unit that was parsed
+   */
+  CompilationUnit parseDirectives(Token token) {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseDirectives");
+    try {
+      _currentToken = token;
+      return _parseDirectives();
+    } finally {
+      instrumentation.log2(2);
+    }
+  }
+
+  /**
    * Parse an expression, starting with the given token.
    *
    * @param token the first token of the expression
    * @return the expression that was parsed, or `null` if the tokens do not represent a
    *         recognizable expression
    */
   Expression parseExpression(Token token) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseExpression");
     try {
       _currentToken = token;
@@ skipping 2821 matching lines @@
     } else if (_matchesKeyword(Keyword.PART)) {
       return _parsePartDirective(commentAndMetadata);
     } else {
       // Internal error: this method should not have been invoked if the current token was something
       // other than one of the above.
       throw new IllegalStateException("parseDirective invoked in an invalid state; currentToken = ${_currentToken}");
     }
   }
 
   /**
+   * Parse the script tag and directives in a compilation unit until the first non-directive is
+   * encountered.
+   *
+   *
+   * <pre>
+   * compilationUnit ::=
+   *     scriptTag? directive*
+   * </pre>
+   *
+   * @return the compilation unit that was parsed
+   */
+  CompilationUnit _parseDirectives() {
+    Token firstToken = _currentToken;
+    ScriptTag scriptTag = null;
+    if (_matches(TokenType.SCRIPT_TAG)) {
+      scriptTag = new ScriptTag(andAdvance);
+    }
+    List<Directive> directives = new List<Directive>();
+    while (!_matches(TokenType.EOF)) {
+      CommentAndMetadata commentAndMetadata = _parseCommentAndMetadata();
+      if ((_matchesKeyword(Keyword.IMPORT) || _matchesKeyword(Keyword.EXPORT) || _matchesKeyword(Keyword.LIBRARY) || _matchesKeyword(Keyword.PART)) && !_tokenMatches(_peek(), TokenType.PERIOD) && !_tokenMatches(_peek(), TokenType.LT) && !_tokenMatches(_peek(), TokenType.OPEN_PAREN)) {
+        directives.add(_parseDirective(commentAndMetadata));
+      } else if (_matches(TokenType.SEMICOLON)) {
+        _advance();
+      } else {
+        while (!_matches(TokenType.EOF)) {
+          _advance();
+        }
+        return new CompilationUnit(firstToken, scriptTag, directives, new List<CompilationUnitMember>(), _currentToken);
+      }
+    }
+    return new CompilationUnit(firstToken, scriptTag, directives, new List<CompilationUnitMember>(), _currentToken);
+  }
+
+  /**
    * Parse a documentation comment.
    *
    * <pre>
    * documentationComment ::=
    *     multiLineComment?
    *   | singleLineComment*
    * </pre>
    *
    * @return the documentation comment that was parsed, or `null` if there was no comment
    */
@@ skipping 4455 matching lines @@
     if (first == null) {
       return second == null;
     } else if (second == null) {
       return false;
     }
     return first.lexeme == second.lexeme;
   }
 }
 Map<String, MethodTrampoline> methodTable_Parser = <String, MethodTrampoline> {
   'parseCompilationUnit_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseCompilationUnit(arg0)),
+  'parseDirectives_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseDirectives(arg0)),
   'parseExpression_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseExpression(arg0)),
   'parseStatement_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseStatement(arg0)),
   'parseStatements_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseStatements(arg0)),
   'parseAnnotation_0': new MethodTrampoline(0, (Parser target) => target.parseAnnotation()),
   'parseArgument_0': new MethodTrampoline(0, (Parser target) => target.parseArgument()),
   'parseArgumentList_0': new MethodTrampoline(0, (Parser target) => target.parseArgumentList()),
   'parseBitwiseOrExpression_0': new MethodTrampoline(0, (Parser target) => target.parseBitwiseOrExpression()),
   'parseBlock_0': new MethodTrampoline(0, (Parser target) => target.parseBlock()),
   'parseClassMember_1': new MethodTrampoline(1, (Parser target, arg0) => target.parseClassMember(arg0)),
   'parseCompilationUnit_0': new MethodTrampoline(0, (Parser target) => target.parseCompilationUnit2()),
@@ skipping 69 matching lines @@
   'parseCombinators_0': new MethodTrampoline(0, (Parser target) => target._parseCombinators()),
   'parseCommentAndMetadata_0': new MethodTrampoline(0, (Parser target) => target._parseCommentAndMetadata()),
   'parseCommentReference_2': new MethodTrampoline(2, (Parser target, arg0, arg1) => target._parseCommentReference(arg0, arg1)),
   'parseCommentReferences_1': new MethodTrampoline(1, (Parser target, arg0) => target._parseCommentReferences(arg0)),
   'parseCompilationUnitMember_1': new MethodTrampoline(1, (Parser target, arg0) => target._parseCompilationUnitMember(arg0)),
   'parseConstExpression_0': new MethodTrampoline(0, (Parser target) => target._parseConstExpression()),
   'parseConstructor_8': new MethodTrampoline(8, (Parser target, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) => target._parseConstructor(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7)),
   'parseConstructorFieldInitializer_0': new MethodTrampoline(0, (Parser target) => target._parseConstructorFieldInitializer()),
   'parseContinueStatement_0': new MethodTrampoline(0, (Parser target) => target._parseContinueStatement()),
   'parseDirective_1': new MethodTrampoline(1, (Parser target, arg0) => target._parseDirective(arg0)),
+  'parseDirectives_0': new MethodTrampoline(0, (Parser target) => target._parseDirectives()),
   'parseDocumentationComment_0': new MethodTrampoline(0, (Parser target) => target._parseDocumentationComment()),
   'parseDoStatement_0': new MethodTrampoline(0, (Parser target) => target._parseDoStatement()),
   'parseEmptyStatement_0': new MethodTrampoline(0, (Parser target) => target._parseEmptyStatement()),
   'parseEqualityExpression_0': new MethodTrampoline(0, (Parser target) => target._parseEqualityExpression()),
   'parseExportDirective_1': new MethodTrampoline(1, (Parser target, arg0) => target._parseExportDirective(arg0)),
   'parseExpressionList_0': new MethodTrampoline(0, (Parser target) => target._parseExpressionList()),
   'parseFinalConstVarOrType_1': new MethodTrampoline(1, (Parser target, arg0) => target._parseFinalConstVarOrType(arg0)),
   'parseFormalParameter_1': new MethodTrampoline(1, (Parser target, arg0) => target._parseFormalParameter(arg0)),
   'parseForStatement_0': new MethodTrampoline(0, (Parser target) => target._parseForStatement()),
   'parseFunctionBody_3': new MethodTrampoline(3, (Parser target, arg0, arg1, arg2) => target._parseFunctionBody(arg0, arg1, arg2)),
@@ skipping 110 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");
     }
   }
 }