improve fasta parser export declaration recovery

pkg/front_end/lib/src/fasta/parser/token_stream_rewriter.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:front_end/src/fasta/errors.dart';
 import 'package:front_end/src/scanner/token.dart' show BeginToken, Token;
 
 /// Provides the capability of inserting tokens into a token stream by rewriting
 /// the previous token to point to the inserted token.
 ///
@@ skipping 15 matching lines @@
   /// Creates a [TokenStreamRewriter] which is prepared to rewrite the token
   /// stream whose first token is [firstToken].
   TokenStreamRewriter(Token firstToken)
       : _head = firstToken.previous ?? (new Token.eof(-1)..next = firstToken);
 
   /// Gets the first token in the stream (which may not be the same token that
   /// was passed to the constructor, if something was inserted before it).
   Token get firstToken => _head.next;
 
   /// Inserts [newToken] into the token stream just before [insertionPoint], and
-  /// fixes up all "next" and "previous" pointers.
+  /// fixes up all "next" and "previous" pointers. Returns [newToken].
   ///
   /// Caller is required to ensure that [insertionPoint] is actually present in
   /// the token stream.
-  void insertTokenBefore(Token newToken, Token insertionPoint) {
+  Token insertTokenBefore(Token newToken, Token insertionPoint) {
     Token previous = _findPreviousToken(insertionPoint);
     _lastPreviousToken = previous;
     newToken.next = insertionPoint;
     previous.next = newToken;
     {
       // Note: even though previousToken is deprecated, we need to hook it up in
       // case any uses of it remain.  Once previousToken is removed it should be
       // safe to remove this block of code.
       insertionPoint.previous = newToken;
       newToken.previous = previous;
     }
+    return newToken;
   }
 
   /// Finds the token that immediately precedes [target].
   Token _findPreviousToken(Token target) {
     // First see if the target has a previous token pointer.  If it does, then
     // we can find the previous token with no extra effort.  Note: it's ok that
     // we're accessing the deprecated member previousToken here, because we have
     // a fallback if it is not available.  Once previousToken is removed, we can
     // remove the "if" test below, and always use the fallback code.
     if (target.previous != null) {
@@ skipping 33 matching lines @@
         nextPos = pos.next;
         if (nextPos == null || nextPos.charOffset > target.charOffset) {
           return null;
         }
       }
       pos = nextPos;
     }
     return pos;
   }
 }