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 290 matching lines @@
       return _parser.parseSimpleIdentifier();
     } else if (identical(_oldNode, node.typeParameters)) {
       return _parser.parseTypeParameterList();
     } else if (identical(_oldNode, node.extendsClause)) {
       return _parser.parseExtendsClause();
     } else if (identical(_oldNode, node.withClause)) {
       return _parser.parseWithClause();
     } else if (identical(_oldNode, node.implementsClause)) {
       return _parser.parseImplementsClause();
     } else if (node.members.contains(_oldNode)) {
-      return _parser.parseClassMember(node.name.name);
+      ClassMember member = _parser.parseClassMember(node.name.name);
+      if (member == null) {
+        throw new InsufficientContextException();
+      }
+      return member;
     }
     return notAChild(node);
   }
 
   ASTNode visitClassTypeAlias(ClassTypeAlias node) {
     if (identical(_oldNode, node.documentationComment)) {
       throw new InsufficientContextException();
     } else if (node.metadata.contains(_oldNode)) {
       return _parser.parseAnnotation();
     } else if (identical(_oldNode, node.name)) {
@@ skipping 1363 matching lines @@
       return parseOperator(commentAndMetadata, modifiers.externalKeyword, null);
     } else if (!matchesIdentifier()) {
       if (isOperator(_currentToken)) {
         //
         // We appear to have found an operator declaration without the 'operator' keyword.
         //
         validateModifiersForOperator(modifiers);
         return parseOperator(commentAndMetadata, modifiers.externalKeyword, null);
       }
       reportError14(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(createSyntheticToken2(TokenType.SEMICOLON)));
+      }
       return null;
     } else if (matches4(peek(), TokenType.PERIOD) && matchesIdentifier2(peek2(2)) && matches4(peek2(3), TokenType.OPEN_PAREN)) {
       return parseConstructor(commentAndMetadata, modifiers.externalKeyword, validateModifiersForConstructor(modifiers), modifiers.factoryKeyword, parseSimpleIdentifier(), andAdvance, parseSimpleIdentifier(), parseFormalParameterList());
     } else if (matches4(peek(), TokenType.OPEN_PAREN)) {
       SimpleIdentifier methodName = parseSimpleIdentifier();
       FormalParameterList parameters = parseFormalParameterList();
       if (matches5(TokenType.COLON) || modifiers.factoryKeyword != null || methodName.name == className) {
         return parseConstructor(commentAndMetadata, modifiers.externalKeyword, validateModifiersForConstructor(modifiers), modifiers.factoryKeyword, methodName, null, null, parameters);
       }
       validateModifiersForGetterOrSetterOrMethod(modifiers);
@@ skipping 1060 matching lines @@
     // Pass in the error code to use to report the error?
     if (identical(type, TokenType.SEMICOLON)) {
       reportError14(ParserErrorCode.EXPECTED_TOKEN, _currentToken.previous, [type.lexeme]);
     } else {
       reportError13(ParserErrorCode.EXPECTED_TOKEN, [type.lexeme]);
     }
     return _currentToken;
   }
 
   /**
+   * If [currentToken] is a semicolon, returns it; otherwise reports error and creates a
+   * synthetic one.
+   *
+   * TODO(scheglov) consider pushing this into [expect]
+   */
+  Token expectSemicolon() {
+    if (matches5(TokenType.SEMICOLON)) {
+      return andAdvance;
+    } else {
+      reportError14(ParserErrorCode.EXPECTED_TOKEN, _currentToken.previous, [";"]);
+      return createSyntheticToken2(TokenType.SEMICOLON);
+    }
+  }
+
+  /**
    * 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) {
     int rangeCount = ranges.length;
     for (int i = 0; i < rangeCount; i++) {
@@ skipping 1041 matching lines @@
    * </pre>
    *
    * @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) {
     // TODO(brianwilkerson) The errors are not getting the right offset/length and are being duplicated.
     if (referenceSource.length == 0) {
-      return null;
+      Token syntheticToken = new SyntheticStringToken(TokenType.IDENTIFIER, "", sourceOffset);
+      return new CommentReference(null, new SimpleIdentifier(syntheticToken));
     }
     try {
       BooleanErrorListener listener = new BooleanErrorListener();
       Scanner scanner = new Scanner(null, new SubSequenceReader(referenceSource, sourceOffset), listener);
       scanner.setSourceStart(1, 1);
       Token firstToken = scanner.tokenize();
       if (listener.errorReported) {
         return null;
       }
       Token newKeyword = null;
@@ skipping 46 matching lines @@
   List<CommentReference> parseCommentReferences(List<Token> tokens) {
     List<CommentReference> references = new List<CommentReference>();
     for (Token token in tokens) {
       String comment = token.lexeme;
       int length = comment.length;
       List<List<int>> codeBlockRanges = getCodeBlockRanges(comment);
       int leftIndex = comment.indexOf('[');
       while (leftIndex >= 0 && leftIndex + 1 < length) {
         List<int> range = findRange(codeBlockRanges, leftIndex);
         if (range == null) {
+          int nameOffset = token.offset + leftIndex + 1;
           int rightIndex = JavaString.indexOf(comment, ']', leftIndex);
           if (rightIndex >= 0) {
             int firstChar = comment.codeUnitAt(leftIndex + 1);
             if (firstChar != 0x27 && firstChar != 0x22) {
               if (isLinkText(comment, rightIndex)) {
               } else {
-                CommentReference reference = parseCommentReference(comment.substring(leftIndex + 1, rightIndex), token.offset + leftIndex + 1);
+                CommentReference reference = parseCommentReference(comment.substring(leftIndex + 1, rightIndex), nameOffset);
                 if (reference != null) {
                   references.add(reference);
                 }
               }
             }
           } else {
+            // terminating ']' is not typed yet
+            int charAfterLeft = comment.codeUnitAt(leftIndex + 1);
+            if (Character.isLetterOrDigit(charAfterLeft)) {
+              int nameEnd = StringUtilities.indexOfFirstNotLetterDigit(comment, leftIndex + 1);
+              String name = comment.substring(leftIndex + 1, nameEnd);
+              Token nameToken = new StringToken(TokenType.IDENTIFIER, name, nameOffset);
+              references.add(new CommentReference(null, new SimpleIdentifier(nameToken)));
+            } else {
+              Token nameToken = new SyntheticStringToken(TokenType.IDENTIFIER, "", nameOffset);
+              references.add(new CommentReference(null, new SimpleIdentifier(nameToken)));
+            }
+            // next character
             rightIndex = leftIndex + 1;
           }
           leftIndex = JavaString.indexOf(comment, '[', rightIndex);
         } else {
           leftIndex = JavaString.indexOf(comment, '[', range[1] + 1);
         }
       }
     }
     return references;
   }
@@ skipping 389 matching lines @@
    *     metadata 'export' stringLiteral combinator*';'
    * </pre>
    *
    * @param commentAndMetadata the metadata to be associated with the directive
    * @return the export directive that was parsed
    */
   ExportDirective parseExportDirective(CommentAndMetadata commentAndMetadata) {
     Token exportKeyword = expect(Keyword.EXPORT);
     StringLiteral libraryUri = parseStringLiteral();
     List<Combinator> combinators = parseCombinators();
-    Token semicolon = expect2(TokenType.SEMICOLON);
+    Token semicolon = expectSemicolon();
     return new ExportDirective(commentAndMetadata.comment, commentAndMetadata.metadata, exportKeyword, libraryUri, combinators, semicolon);
   }
 
   /**
    * Parse a list of expressions.
    *
    * <pre>
    * expressionList ::=
    *     expression (',' expression)*
    * </pre>
@@ skipping 472 matching lines @@
   ImportDirective parseImportDirective(CommentAndMetadata commentAndMetadata) {
     Token importKeyword = expect(Keyword.IMPORT);
     StringLiteral libraryUri = parseStringLiteral();
     Token asToken = null;
     SimpleIdentifier prefix = null;
     if (matches(Keyword.AS)) {
       asToken = andAdvance;
       prefix = parseSimpleIdentifier();
     }
     List<Combinator> combinators = parseCombinators();
-    Token semicolon = expect2(TokenType.SEMICOLON);
+    Token semicolon = expectSemicolon();
     return new ImportDirective(commentAndMetadata.comment, commentAndMetadata.metadata, importKeyword, libraryUri, asToken, prefix, combinators, semicolon);
   }
 
   /**
    * Parse a list of initialized identifiers.
    *
    * <pre>
    * ?? ::=
    *     'static'? ('var' | type) initializedIdentifierList ';'
    *   | 'final' type? initializedIdentifierList ';'
@@ skipping 636 matching lines @@
           }
         } else {
           operand = parseAssignableSelector(operand, true);
         }
       } while (matches5(TokenType.OPEN_SQUARE_BRACKET) || matches5(TokenType.PERIOD) || matches5(TokenType.OPEN_PAREN));
       return operand;
     }
     if (!_currentToken.type.isIncrementOperator) {
       return operand;
     }
-    if (operand is Literal || operand is FunctionExpressionInvocation) {
-      reportError13(ParserErrorCode.MISSING_ASSIGNABLE_SELECTOR, []);
-    }
+    ensureAssignable(operand);
     Token operator = andAdvance;
     return new PostfixExpression(operand, operator);
   }
 
   /**
    * Parse a primary expression.
    *
    * <pre>
    * primary ::=
    *     thisExpression
@@ skipping 1457 matching lines @@
 
   /**
    * Validate that the given set of modifiers is appropriate for a constructor and return the
    * 'const' keyword if there is one.
    *
    * @param modifiers the modifiers being validated
    * @return the 'const' or 'final' keyword associated with the constructor
    */
   Token validateModifiersForConstructor(Modifiers modifiers) {
     if (modifiers.abstractKeyword != null) {
-      reportError13(ParserErrorCode.ABSTRACT_CLASS_MEMBER, []);
+      reportError14(ParserErrorCode.ABSTRACT_CLASS_MEMBER, modifiers.abstractKeyword, []);
     }
     if (modifiers.finalKeyword != null) {
       reportError14(ParserErrorCode.FINAL_CONSTRUCTOR, modifiers.finalKeyword, []);
     }
     if (modifiers.staticKeyword != null) {
       reportError14(ParserErrorCode.STATIC_CONSTRUCTOR, modifiers.staticKeyword, []);
     }
     if (modifiers.varKeyword != null) {
       reportError14(ParserErrorCode.CONSTRUCTOR_WITH_RETURN_TYPE, modifiers.varKeyword, []);
     }
@@ skipping 2632 matching lines @@
       if ("\n" == separator) {
         _writer.print("\n");
         indent();
       } else if (i > 0) {
         _writer.print(separator);
       }
       _writer.print(tokens[i].lexeme);
     }
   }
 }