new handleInvalidTopLevelDeclaration event in fasta parser

pkg/front_end/lib/src/fasta/parser/parser.dart

 // Copyright (c) 2012, 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.
 
 library fasta.parser.parser;
 
 import '../fasta_codes.dart' show Code, Message, Template;
 
 import '../fasta_codes.dart' as fasta;
 
@@ skipping 206 matching lines @@
 
   bool get inAsync {
     return asyncState == AsyncModifier.Async ||
         asyncState == AsyncModifier.AsyncStar;
   }
 
   bool get inPlainSync => asyncState == AsyncModifier.Sync;
 
   Token parseUnit(Token token) {
     listener.beginCompilationUnit(token);
-    int count = 0;
+    _topLevelDeclarationCount = 0;
     while (!identical(token.kind, EOF_TOKEN)) {
       token = parseTopLevelDeclaration(token);
-      count++;
     }
-    listener.endCompilationUnit(count, token);
+    listener.endCompilationUnit(_topLevelDeclarationCount, token);
     return token;
   }
 
+  int _topLevelDeclarationCount = 0;

[ahe, 2017/08/07 13:31:00]

Why is this a field now?

[danrubel, 2017/08/15 20:13:32]

Per our discussion, I've reverted this so that invalid top level declarations
are included in the count. Each listener will have to decide how invalid
declarations are to be handled.

+
   Token parseTopLevelDeclaration(Token token) {
-    token = _parseTopLevelDeclaration(token);
+    Token start = token;
+    if (token.type == TokenType.SCRIPT_TAG) {
+      token = parseScript(token);
+    } else {
+      token = parseMetadataStar(token);
+      final String value = token.stringValue;
+      if ((identical(value, 'abstract') && optional('class', token.next)) ||
+          identical(value, 'class')) {
+        token = parseClassOrNamedMixinApplication(token);
+      } else if (identical(value, 'enum')) {
+        token = parseEnum(token);
+      } else if (identical(value, 'typedef') &&
+          (token.next.isIdentifier || optional("void", token.next))) {
+        token = parseTypedef(token);
+      } else if (identical(value, 'library')) {
+        token = parseLibraryName(token);
+      } else if (identical(value, 'import')) {
+        token = parseImport(token);
+      } else if (identical(value, 'export')) {
+        token = parseExport(token);
+      } else if (identical(value, 'part')) {
+        token = parsePartOrPartOf(token);
+      } else if (token.type == TokenType.IDENTIFIER || token.keyword != null) {
+        token = parseTopLevelMember(token);
+      } else {
+        reportRecoverableErrorWithToken(
+            token, fasta.templateExpectedDeclaration);
+        listener.handleInvalidTopLevelDeclaration(start, token);
+        return token.next;
+      }
+    }
     listener.endTopLevelDeclaration(token);
+    ++_topLevelDeclarationCount;
     return token;
   }
 
-  Token _parseTopLevelDeclaration(Token token) {
-    if (identical(token.type, TokenType.SCRIPT_TAG)) {
-      return parseScript(token);
-    }
-    token = parseMetadataStar(token);
-    final String value = token.stringValue;
-    if ((identical(value, 'abstract') && optional('class', token.next)) ||
-        identical(value, 'class')) {
-      return parseClassOrNamedMixinApplication(token);
-    } else if (identical(value, 'enum')) {
-      return parseEnum(token);
-    } else if (identical(value, 'typedef') &&
-        (token.next.isIdentifier || optional("void", token.next))) {
-      return parseTypedef(token);
-    } else if (identical(value, 'library')) {
-      return parseLibraryName(token);
-    } else if (identical(value, 'import')) {
-      return parseImport(token);
-    } else if (identical(value, 'export')) {
-      return parseExport(token);
-    } else if (identical(value, 'part')) {
-      return parsePartOrPartOf(token);
-    } else {
-      return parseTopLevelMember(token);
-    }
-  }
-
   /// library qualified ';'
   Token parseLibraryName(Token token) {
     Token libraryKeyword = token;
     listener.beginLibraryName(libraryKeyword);
     assert(optional('library', token));
     token = parseQualified(token.next, IdentifierContext.libraryName,
         IdentifierContext.libraryNameContinuation);
     Token semicolon = token;
     token = expect(';', token);
     listener.endLibraryName(libraryKeyword, semicolon);
@@ skipping 3724 matching lines @@
   }
 
   Token reportUnexpectedToken(Token token) {
     return reportUnrecoverableErrorWithToken(
         token, fasta.templateUnexpectedToken);
   }
 }
 
 // TODO(ahe): Remove when analyzer supports generalized function syntax.
 typedef _MessageWithArgument<T> = Message Function(T);