improve fasta export directive recovery

pkg/front_end/lib/src/fasta/parser/listener.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.listener;
 
 import '../../scanner/token.dart' show Token, TokenType;
 
 import '../fasta_codes.dart' show Message;
 
 import '../util/link.dart' show Link;
 
 import 'assert.dart' show Assert;
 
 import 'formal_parameter_kind.dart' show FormalParameterKind;
 
 import 'identifier_context.dart' show IdentifierContext;
 
 import 'member_kind.dart' show MemberKind;
 
 import 'parser_error.dart' show ParserError;
 
+import 'token_stream_rewriter.dart';
+
 /// A parser event listener that does nothing except throw exceptions
 /// on parser errors.
 ///
 /// Events are methods that begin with one of: `begin`, `end`, or `handle`.
 ///
 /// Events starting with `begin` and `end` come in pairs. Normally, a
 /// `beginFoo` event is followed by an `endFoo` event. There's a few exceptions
 /// documented below.
 ///
 /// Events starting with `handle` are used when isn't possible to have a begin
 /// event.
 class Listener {
   final List<ParserError> recoverableErrors = <ParserError>[];
 
+  /// The first token in the parse stream and used during parser recovery.
+  /// This is automatically set by the [beginCompilationUnit] event,
+  /// but must be manually set when parsing anything smaller.
+  Token firstToken;
+
+  /// A rewriter for inserting synthetic tokens.
+  /// Access using [rewriter] for lazy initialization.
+  TokenStreamRewriter _tokenRewriter;
+
+  TokenStreamRewriter get rewriter {
+    assert(firstToken != null, 'firstToken must be set for parser recovery');
+    _tokenRewriter ??= new TokenStreamRewriter(firstToken);
+    return _tokenRewriter;
+  }
+
+  Listener();
+
   Uri get uri => null;
 
   void logEvent(String name) {}
 
   set suppressParseErrors(bool value) {}
 
   void beginArguments(Token token) {}
 
   void endArguments(int count, Token beginToken, Token endToken) {
     logEvent("Arguments");
@@ skipping 58 matching lines @@
       Token endToken) {
     logEvent("ClassDeclaration");
   }
 
   void beginCombinators(Token token) {}
 
   void endCombinators(int count) {
     logEvent("Combinators");
   }
 
-  void beginCompilationUnit(Token token) {}
+  void beginCompilationUnit(Token token) {
+    firstToken = token;
+  }
 
   void endCompilationUnit(int count, Token token) {
     logEvent("CompilationUnit");
   }
 
   void beginConstLiteral(Token token) {}
 
   void endConstLiteral(Token token) {
     logEvent("ConstLiteral");
   }
@@ skipping 994 matching lines @@
   void discardTypeReplacedWithCommentTypeAssign() {}
 
   /// Creates a new synthetic token whose `next` pointer points to [next].
   ///
   /// If [next] is `null`, `null` is returned.
   Token newSyntheticToken(Token next) {
     if (next == null) return null;
     return new Token(TokenType.RECOVERY, next.charOffset)..next = next;
   }
 }