new handleInvalidTopLevelDeclaration event in fasta parser

pkg/analyzer/test/generated/parser_fasta_test.dart

 // Copyright (c) 2017, 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.
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart' as analyzer;
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart' show ErrorReporter;
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/fasta/ast_builder.dart';
@@ skipping 449 matching lines @@
                   token,
                   inFunctionType
                       ? fasta.MemberKind.GeneralizedFunctionType
                       : fasta.MemberKind.NonStaticMethod);
             },
         errorCodes) as FormalParameterList;
   }
 
   @override
   CompilationUnitMember parseFullCompilationUnitMember() {
-    return _parserProxy._run((parser) => parser.parseTopLevelDeclaration);
+    return _parserProxy._run(
+        (parser) => parser.parseTopLevelDeclaration, 'CompilationUnit');
   }
 
   @override
   Directive parseFullDirective() {
-    return _parserProxy._run((parser) => parser.parseTopLevelDeclaration);
+    return _parserProxy._run(
+        (parser) => parser.parseTopLevelDeclaration, 'CompilationUnit');
   }
 
   @override
   FunctionExpression parseFunctionExpression(String code) {
     return _parseExpression(code);
   }
 
   @override
   InstanceCreationExpression parseInstanceCreationExpression(
       String code, analyzer.Token newToken) {
@@ skipping 151 matching lines @@
   }
 
   Object _runParser(
       String source, ParseFunction getParseFunction(fasta.Parser parser),
       [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     if (errorCodes.isNotEmpty) {
       // TODO(paulberry): Check that the parser generates the proper errors.
       throw new UnimplementedError();
     }
     createParser(source);
-    return _parserProxy._run(getParseFunction);
+    return _parserProxy._run(getParseFunction, null);
   }
 }
 
 /**
  * Tests of the fasta parser based on [FormalParameterParserTestMixin].
  */
 @reflectiveTest
 class FormalParameterParserTest_Fasta extends FastaParserTestCase
     with FormalParameterParserTestMixin {
   @override
@@ skipping 127 matching lines @@
    * The builder which creates the analyzer AST data structures expected by the
    * analyzer parser tests.
    */
   final AstBuilder _astBuilder;
 
   /**
    * The error listener to which scanner and parser errors will be reported.
    */
   final GatheringErrorListener _errorListener;
 
+  final ForwardingTestListener _eventListener;
+
   /**
    * Creates a [ParserProxy] which is prepared to begin parsing at the given
    * Fasta token.
    */
   factory ParserProxy(analyzer.Token startingToken,
       {bool enableGenericMethodComments: false}) {
     var library = new KernelLibraryBuilderProxy();
     var member = new BuilderProxy();
     var scope = new ScopeProxy();
     TestSource source = new TestSource();
     var errorListener = new GatheringErrorListener();
     var errorReporter = new ErrorReporter(errorListener, source);
     var astBuilder =
         new AstBuilder(errorReporter, library, member, scope, true);
     astBuilder.parseGenericMethodComments = enableGenericMethodComments;
-    var fastaParser = new fasta.Parser(new ForwardingTestListener(astBuilder));
+    var eventListener = new ForwardingTestListener(astBuilder);
+    var fastaParser = new fasta.Parser(eventListener);
     astBuilder.parser = fastaParser;
     return new ParserProxy._(
-        startingToken, fastaParser, astBuilder, errorListener);
+        startingToken, fastaParser, astBuilder, errorListener, eventListener);
   }
 
   ParserProxy._(this._currentFastaToken, this._fastaParser, this._astBuilder,
-      this._errorListener);
+      this._errorListener, this._eventListener);
 
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   ClassMember parseClassMember(String className) {
     _astBuilder.className = className;
-    var result = _run((parser) => parser.parseMember) as ClassMember;
+    var result =
+        _run((parser) => parser.parseMember, 'CompilationUnit') as ClassMember;
     _astBuilder.className = null;
     return result;
   }
 
   @override
   CompilationUnit parseCompilationUnit2() {
-    return _run((parser) => parser.parseUnit) as CompilationUnit;
+    return _run((parser) => parser.parseUnit, null) as CompilationUnit;
   }
 
   /**
    * Runs a single parser function, and returns the result as an analyzer AST.
    */
-  Object _run(ParseFunction getParseFunction(fasta.Parser parser)) {
+  Object _run(ParseFunction getParseFunction(fasta.Parser parser),
+      String enclosingEvent) {
+    _eventListener.enclosingEvent = enclosingEvent;
     var parseFunction = getParseFunction(_fastaParser);
     _currentFastaToken = parseFunction(_currentFastaToken);
     expect(_currentFastaToken.isEof, isTrue);
     expect(_astBuilder.stack, hasLength(1));
     return _astBuilder.pop();
   }
 }
 
 /**
  * Proxy implementation of [Scope] used by Fasta parser tests.
@@ skipping 162 matching lines @@
     assertNoErrors();
   }
 
   @failingTest
   void test_parseCompilationUnitMember_abstractAsPrefix2() {
     // TODO(danrubel): should not be generating an error
     super.test_parseCompilationUnitMember_abstractAsPrefix();
     assertNoErrors();
   }
 }