New 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 1145 matching lines @@
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during the parse
    */
   IncrementalParser(Source source, TokenMap tokenMap, AnalysisErrorListener errorListener) {
     this._source = source;
     this._tokenMap = tokenMap;
     this._errorListener = errorListener;
   }
 
   /**
-   * Given a range of tokens that were re-scanned, re-parse the minimimum number of tokens to
-   * produce a consistent AST structure. The range is represented by the first and last tokens in
-   * the range. The tokens are assumed to be contained in the same token stream.
+   * Given a range of tokens that were re-scanned, re-parse the minimum number of tokens to produce
+   * a consistent AST structure. The range is represented by the first and last tokens in the range.
+   * The tokens are assumed to be contained in the same token stream.
    *
-   * @param firstToken the first token in the range of tokens that were re-scanned or `null`
-   *          if no new tokens were inserted
-   * @param lastToken the last token in the range of tokens that were re-scanned or `null` if
-   *          no new tokens were inserted
+   * @param leftToken the token in the new token stream immediately to the left of the range of
+   *          tokens that were inserted
+   * @param rightToken the token in the new token stream immediately to the right of the range of
+   *          tokens that were inserted
    * @param originalStart the offset in the original source of the first character that was modified
    * @param originalEnd the offset in the original source of the last character that was modified
    */
-  ASTNode reparse(ASTNode originalStructure, Token firstToken, Token lastToken, int originalStart, int originalEnd) {
+  ASTNode reparse(ASTNode originalStructure, Token leftToken, Token rightToken, int originalStart, int originalEnd) {
     ASTNode oldNode = null;
     ASTNode newNode = null;
-    if (firstToken != null) {
-      if (originalEnd < originalStart) {
-        oldNode = new NodeLocator.con1(originalStart).searchWithin(originalStructure);
-      } else {
-        oldNode = new NodeLocator.con2(originalStart, originalEnd).searchWithin(originalStructure);
+    Token firstToken = leftToken.next;
+    if (identical(firstToken, rightToken)) {
+      firstToken = leftToken;
+    }
+    if (originalEnd < originalStart) {
+      oldNode = new NodeLocator.con1(originalStart).searchWithin(originalStructure);
+    } else {
+      oldNode = new NodeLocator.con2(originalStart, originalEnd).searchWithin(originalStructure);
+    }
+    int originalOffset = oldNode.offset;
+    Token parseToken = findTokenAt(firstToken, originalOffset);
+    if (parseToken == null) {
+      return null;
+    }
+    Parser parser = new Parser(_source, _errorListener);
+    parser.currentToken = parseToken;
+    while (newNode == null) {
+      ASTNode parent = oldNode.parent;
+      if (parent == null) {
+        parseToken = findFirstToken(parseToken);
+        parser.currentToken = parseToken;
+        return parser.parseCompilationUnit2() as ASTNode;
       }
-      int originalOffset = oldNode.offset;
-      Token parseToken = findTokenAt(firstToken, originalOffset);
-      if (parseToken == null) {
+      bool advanceToParent = false;
+      try {
+        IncrementalParseDispatcher dispatcher = new IncrementalParseDispatcher(parser, oldNode);
+        newNode = parent.accept(dispatcher);
+        Token mappedToken = _tokenMap.get(oldNode.endToken.next);
+        if (mappedToken == null || mappedToken.offset != newNode.endToken.next.offset || newNode.offset != oldNode.offset) {
+          advanceToParent = true;
+        }
+      } on InsufficientContextException catch (exception) {
+        advanceToParent = true;
+      } on JavaException catch (exception) {
         return null;
       }
-      Parser parser = new Parser(_source, _errorListener);
-      parser.currentToken = parseToken;
-      while (newNode == null) {
-        ASTNode parent = oldNode.parent;
-        if (parent == null) {
-          parseToken = findFirstToken(parseToken);
-          parser.currentToken = parseToken;
-          return parser.parseCompilationUnit2() as ASTNode;
-        }
-        try {
-          IncrementalParseDispatcher dispatcher = new IncrementalParseDispatcher(parser, oldNode);
-          newNode = parent.accept(dispatcher);
-        } on InsufficientContextException catch (exception) {
-          oldNode = parent;
-          originalOffset = oldNode.offset;
-          parseToken = findTokenAt(parseToken, originalOffset);
-          parser.currentToken = parseToken;
-        } on JavaException catch (exception) {
-          return null;
-        }
+      if (advanceToParent) {
+        newNode = null;
+        oldNode = parent;
+        originalOffset = oldNode.offset;
+        parseToken = findTokenAt(parseToken, originalOffset);
+        parser.currentToken = parseToken;
       }
-      if (newNode.offset != originalOffset) {
-        return null;
-      }
-      if (identical(oldNode, originalStructure)) {
-        return newNode as ASTNode;
-      }
+    }
+    if (identical(oldNode, originalStructure)) {
       ResolutionCopier.copyResolutionData(oldNode, newNode);
+      return newNode as ASTNode;
     }
+    ResolutionCopier.copyResolutionData(oldNode, newNode);
     IncrementalASTCloner cloner = new IncrementalASTCloner(oldNode, newNode, _tokenMap);
     return originalStructure.accept(cloner) as ASTNode;
   }
 
   /**
    * Return the first (non-EOF) token in the token stream containing the given token.
    *
    * @param firstToken the token from which the search is to begin
    * @return the first token in the token stream containing the given token
    */
@@ skipping 105 matching lines @@
   /**
    * Parse a compilation unit, starting with the given token.
    *
    * @param token the first token of the compilation unit
    * @return the compilation unit that was parsed
    */
   CompilationUnit parseCompilationUnit(Token token) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.Parser.parseCompilationUnit");
     try {
       _currentToken = token;
-      CompilationUnit compilationUnit = parseCompilationUnit2();
-      gatherTodoComments(token);
-      return compilationUnit;
+      return parseCompilationUnit2();
     } 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
@@ skipping 357 matching lines @@
           if (directive is ExportDirective) {
             reportError10(ParserErrorCode.EXPORT_DIRECTIVE_AFTER_PART_DIRECTIVE, (directive as NamespaceDirective).keyword, []);
           } else if (directive is ImportDirective) {
             reportError10(ParserErrorCode.IMPORT_DIRECTIVE_AFTER_PART_DIRECTIVE, (directive as NamespaceDirective).keyword, []);
           }
         }
         if (directive is PartOfDirective) {
           if (partOfDirectiveFound) {
             reportError9(ParserErrorCode.MULTIPLE_PART_OF_DIRECTIVES, []);
           } else {
-            for (Directive precedingDirective in directives) {
-              reportError10(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART, precedingDirective.keyword, []);
+            int directiveCount = directives.length;
+            for (int i = 0; i < directiveCount; i++) {
+              reportError10(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART, directives[i].keyword, []);
             }
             partOfDirectiveFound = true;
           }
         } else {
           if (partOfDirectiveFound) {
             reportError10(ParserErrorCode.NON_PART_OF_DIRECTIVE_IN_PART, directive.keyword, []);
           }
         }
         directives.add(directive);
       } else if (matches5(TokenType.SEMICOLON)) {
@@ skipping 785 matching lines @@
       }
     }
     return false;
   }
 
   /**
    * Create a synthetic identifier.
    *
    * @return the synthetic identifier that was created
    */
-  SimpleIdentifier createSyntheticIdentifier() => new SimpleIdentifier.full(createSyntheticToken2(TokenType.IDENTIFIER));
+  SimpleIdentifier createSyntheticIdentifier() {
+    Token syntheticToken;
+    if (identical(_currentToken.type, TokenType.KEYWORD)) {
+      syntheticToken = injectToken(new SyntheticStringToken(TokenType.IDENTIFIER, _currentToken.lexeme, _currentToken.offset));
+    } else {
+      syntheticToken = createSyntheticToken2(TokenType.IDENTIFIER);
+    }
+    return new SimpleIdentifier.full(syntheticToken);
+  }
 
   /**
    * Create a synthetic string literal.
    *
    * @return the synthetic string literal that was created
    */
   SimpleStringLiteral createSyntheticStringLiteral() => new SimpleStringLiteral.full(createSyntheticToken2(TokenType.STRING), "");
 
   /**
    * Create a synthetic token representing the given keyword.
    *
    * @return the synthetic token that was created
    */
-  Token createSyntheticToken(Keyword keyword) => new Parser_SyntheticKeywordToken(keyword, _currentToken.offset);
+  Token createSyntheticToken(Keyword keyword) => injectToken(new Parser_SyntheticKeywordToken(keyword, _currentToken.offset));
 
   /**
    * Create a synthetic token with the given type.
    *
    * @return the synthetic token that was created
    */
-  Token createSyntheticToken2(TokenType type) => new StringToken(type, "", _currentToken.offset);
+  Token createSyntheticToken2(TokenType type) => injectToken(new StringToken(type, "", _currentToken.offset));
 
   /**
    * Check that the given expression is assignable and report an error if it isn't.
    *
    * <pre>
    * assignableExpression ::=
    *     primary (arguments* assignableSelector)+
    *   | 'super' assignableSelector
    *   | identifier
    *
@@ skipping 46 matching lines @@
 
   /**
    * Search the given list of ranges for a range that contains the given index. Return the range
    * that was found, or `null` if none of the ranges contain the index.
    *
    * @param ranges the ranges to be searched
    * @param index the index contained in the returned range
    * @return the range that was found
    */
   List<int> findRange(List<List<int>> ranges, int index) {
-    for (List<int> range in ranges) {
+    int rangeCount = ranges.length;
+    for (int i = 0; i < rangeCount; i++) {
+      List<int> range = ranges[i];
       if (range[0] <= index && index <= range[1]) {
         return range;
       } else if (index < range[0]) {
         return null;
       }
     }
     return null;
   }
 
-  void gatherTodoComments(Token token) {
-    while (token != null && token.type != TokenType.EOF) {
-      Token commentToken = token.precedingComments;
-      while (commentToken != null) {
-        if (identical(commentToken.type, TokenType.SINGLE_LINE_COMMENT) || identical(commentToken.type, TokenType.MULTI_LINE_COMMENT)) {
-          scrapeTodoComment(commentToken);
-        }
-        commentToken = commentToken.next;
-      }
-      token = token.next;
-    }
-  }
-
   /**
    * Advance to the next token in the token stream, making it the new current token.
    *
    * @return the token that was current before this method was invoked
    */
   Token get andAdvance {
     Token token = _currentToken;
     advance();
     return token;
   }
@@ skipping 66 matching lines @@
    */
   bool hasReturnTypeInTypeAlias() {
     Token next = skipReturnType(_currentToken);
     if (next == null) {
       return false;
     }
     return matchesIdentifier2(next);
   }
 
   /**
+   * Inject the given token into the token stream immediately before the current token.
+   *
+   * @param token the token to be added to the token stream
+   * @return the token that was just added to the token stream
+   */
+  Token injectToken(Token token) {
+    Token previous = _currentToken.previous;
+    token.setNext(_currentToken);
+    previous.setNext(token);
+    return token;
+  }
+
+  /**
    * Return `true` if the current token appears to be the beginning of a function declaration.
    *
    * @return `true` if the current token appears to be the beginning of a function declaration
    */
   bool isFunctionDeclaration() {
     if (matches(Keyword.VOID)) {
       return true;
     }
     Token afterReturnType = skipTypeName(_currentToken);
     if (afterReturnType == null) {
@@ skipping 877 matching lines @@
    * @param referenceSource the source occurring between the square brackets within a documentation
    *          comment
    * @param sourceOffset the offset of the first character of the reference source
    * @return the comment reference that was parsed, or `null` if no reference could be found
    */
   CommentReference parseCommentReference(String referenceSource, int sourceOffset) {
     if (referenceSource.length == 0) {
       return null;
     }
     try {
-      List<bool> errorFound = [false];
-      AnalysisErrorListener listener = new AnalysisErrorListener_16(errorFound);
+      BooleanErrorListener listener = new BooleanErrorListener();
       Scanner scanner = new Scanner(null, new SubSequenceReader(new CharSequence(referenceSource), sourceOffset), listener);
       scanner.setSourceStart(1, 1);
       Token firstToken = scanner.tokenize();
-      if (errorFound[0]) {
+      if (listener.errorReported) {
         return null;
       }
       Token newKeyword = null;
       if (matches3(firstToken, Keyword.NEW)) {
         newKeyword = firstToken;
         firstToken = firstToken.next;
       }
       if (matchesIdentifier2(firstToken)) {
         Token secondToken = firstToken.next;
         Token thirdToken = secondToken.next;
@@ skipping 220 matching lines @@
     FunctionBody body;
     if (matches5(TokenType.EQ)) {
       separator = andAdvance;
       redirectedConstructor = parseConstructorName();
       body = new EmptyFunctionBody.full(expect2(TokenType.SEMICOLON));
       if (factoryKeyword == null) {
         reportError(ParserErrorCode.REDIRECTION_IN_NON_FACTORY_CONSTRUCTOR, redirectedConstructor, []);
       }
     } else {
       body = parseFunctionBody(true, ParserErrorCode.MISSING_FUNCTION_BODY, false);
-      if (constKeyword != null && factoryKeyword != null) {
+      if (constKeyword != null && factoryKeyword != null && externalKeyword == null) {
         reportError10(ParserErrorCode.CONST_FACTORY, factoryKeyword, []);
       } else if (body is EmptyFunctionBody) {
         if (factoryKeyword != null && externalKeyword == null) {
           reportError10(ParserErrorCode.FACTORY_WITHOUT_BODY, factoryKeyword, []);
         }
       } else {
         if (constKeyword != null) {
           reportError(ParserErrorCode.CONST_CONSTRUCTOR_WITH_BODY, body, []);
         } else if (!bodyAllowed) {
           reportError(ParserErrorCode.EXTERNAL_CONSTRUCTOR_WITH_BODY, body, []);
@@ skipping 1687 matching lines @@
       Token defaultKeyword = null;
       List<SwitchMember> members = new List<SwitchMember>();
       while (!matches5(TokenType.EOF) && !matches5(TokenType.CLOSE_CURLY_BRACKET)) {
         List<Label> labels = new List<Label>();
         while (matchesIdentifier() && matches4(peek(), TokenType.COLON)) {
           SimpleIdentifier identifier = parseSimpleIdentifier();
           String label = identifier.token.lexeme;
           if (definedLabels.contains(label)) {
             reportError10(ParserErrorCode.DUPLICATE_LABEL_IN_SWITCH_STATEMENT, identifier.token, [label]);
           } else {
-            javaSetAdd(definedLabels, label);
+            definedLabels.add(label);
           }
           Token colon = expect2(TokenType.COLON);
           labels.add(new Label.full(identifier, colon));
         }
         if (matches(Keyword.CASE)) {
           Token caseKeyword = andAdvance;
           Expression caseExpression = parseExpression2();
           Token colon = expect2(TokenType.COLON);
           members.add(new SwitchCase.full(labels, caseKeyword, caseExpression, colon, parseStatements2()));
           if (defaultKeyword != null) {
@@ skipping 434 matching lines @@
    *
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportError10(ParserErrorCode errorCode, Token token, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(_source, token.offset, token.length, errorCode, arguments));
   }
 
   /**
-   * Look for user defined tasks in comments and convert them into info level analysis issues.
-   *
-   * @param commentToken the comment token to analyze
-   */
-  void scrapeTodoComment(Token commentToken) {
-    JavaPatternMatcher matcher = new JavaPatternMatcher(TodoCode.TODO_REGEX, commentToken.lexeme);
-    if (matcher.find()) {
-      int offset = commentToken.offset + matcher.start() + matcher.group(1).length;
-      int length = matcher.group(2).length;
-      // _errorListener.onError(new AnalysisError.con2(_source, offset, length, TodoCode.TODO, [matcher.group(2)]));
-    }
-  }
-
-  /**
    * Parse the 'final', 'const', 'var' or type preceding a variable declaration, starting at the
    * given token, without actually creating a type or changing the current token. Return the token
    * following the type that was parsed, or `null` if the given token is not the first token
    * in a valid type.
    *
    * <pre>
    * finalConstVarOrType ::=
    *   | 'final' type?
    *   | 'const' type?
    *   | 'var'
@@ skipping 777 matching lines @@
    * @param keyword the keyword being represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   Parser_SyntheticKeywordToken(Keyword keyword, int offset) : super(keyword, offset);
 
   Token copy() => new Parser_SyntheticKeywordToken(keyword, offset);
 
   int get length => 0;
 }
 
-class AnalysisErrorListener_16 implements AnalysisErrorListener {
-  List<bool> errorFound;
-
-  AnalysisErrorListener_16(this.errorFound);
-
-  void onError(AnalysisError error) {
-    errorFound[0] = true;
-  }
-}
-
 /**
  * The enumeration `ParserErrorCode` defines the error codes used for errors detected by the
  * parser. The convention for this class is for the name of the error code to indicate the problem
  * that caused the error to be generated and for the error message to explain what is wrong and,
  * when appropriate, how the problem can be corrected.
  *
  * @coverage dart.engine.parser
  */
 class ParserErrorCode extends Enum<ParserErrorCode> implements ErrorCode {
   static final ParserErrorCode ABSTRACT_CLASS_MEMBER = new ParserErrorCode.con3('ABSTRACT_CLASS_MEMBER', 0, "Members of classes cannot be declared to be 'abstract'");
@@ skipping 2364 matching lines @@
       if ("\n" == separator) {
         _writer.print("\n");
         indent();
       } else if (i > 0) {
         _writer.print(separator);
       }
       _writer.print(tokens[i].lexeme);
     }
   }
 }