improve fasta parser export declaration recovery

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
         FastaCode,
         FastaMessage,
@@ skipping 59 matching lines @@
 import '../scanner/recover.dart' show closeBraceFor, skipToEof;
 
 import '../../scanner/token.dart'
     show
         ASSIGNMENT_PRECEDENCE,
         BeginToken,
         CASCADE_PRECEDENCE,
         EQUALITY_PRECEDENCE,
         POSTFIX_PRECEDENCE,
         RELATIONAL_PRECEDENCE,
+        SyntheticStringToken,
         TokenType;
 
 import '../scanner/token.dart' show isUserDefinableOperator;
 
 import '../scanner/token_constants.dart'
     show
         COMMA_TOKEN,
         DOUBLE_TOKEN,
         EOF_TOKEN,
         EQ_TOKEN,
@@ skipping 17 matching lines @@
 
 import '../scanner/characters.dart' show $CLOSE_CURLY_BRACKET;
 
 import '../util/link.dart' show Link;
 
 import 'async_modifier.dart' show AsyncModifier;
 
 import 'listener.dart' show Listener;
 
 import 'identifier_context.dart' show IdentifierContext;
+import 'package:front_end/src/fasta/parser/token_stream_rewriter.dart';
 
 /// Returns true if [token] is the symbol or keyword [value].
 bool optional(String value, Token token) {
   return identical(value, token.stringValue);
 }
 
 class FormalParameterType {
   final String type;
   const FormalParameterType(this.type);
   bool get isRequired => this == REQUIRED;
@@ skipping 176 matching lines @@
 /// modifiers such as `abstract`, `final`, `static`, etc. Historically, dart2js
 /// would handle such errors in later phases. We hope that these cases will go
 /// away as Fasta matures.
 class Parser {
   final Listener listener;
 
   Uri get uri => listener.uri;
 
   bool mayParseFunctionExpressions = true;
 
+  TokenStreamRewriter _rewriter;
+
   /// Represents parser state: what asynchronous syntax is allowed in the
   /// function being currently parsed. In rare situations, this can be set by
   /// external clients, for example, to parse an expression outside a function.
   AsyncModifier asyncState = AsyncModifier.Sync;
 
   Parser(this.listener);
 
   bool get inGenerator {
     return asyncState == AsyncModifier.AsyncStar ||
         asyncState == AsyncModifier.SyncStar;
   }
 
   bool get inAsync {
     return asyncState == AsyncModifier.Async ||
         asyncState == AsyncModifier.AsyncStar;
   }
 
   bool get inPlainSync => asyncState == AsyncModifier.Sync;
 
   Token parseUnit(Token token) {
+    _rewriter = new TokenStreamRewriter(token);
     listener.beginCompilationUnit(token);
     int count = 0;
     while (!identical(token.kind, EOF_TOKEN)) {
       token = parseTopLevelDeclaration(token);
       count++;
     }
     listener.endCompilationUnit(count, token);
     return token;
   }
 
@@ skipping 109 matching lines @@
     }
     listener.endDottedName(count, firstIdentifier);
     return token;
   }
 
   /// export uri conditional-uris* combinator* ';'
   Token parseExport(Token token) {
     Token exportKeyword = token;
     listener.beginExport(exportKeyword);
     assert(optional('export', token));
-    token = parseLiteralStringOrRecoverExpression(token.next);
+    token = parseLiteralString(ensureLiteralString(token.next));
     token = parseConditionalUris(token);
     token = parseCombinators(token);
     Token semicolon = token;
     token = expect(';', token);
     listener.endExport(exportKeyword, semicolon);
     return token;
   }
 
   Token parseCombinators(Token token) {
     listener.beginCombinators(token);
@@ skipping 605 matching lines @@
       } else if (optional('yield', token)) {
         reportRecoverableErrorCode(token, codeYieldAsIdentifier);
       } else if (optional('async', token)) {
         reportRecoverableErrorCode(token, codeAsyncAsIdentifier);
       }
     }
     listener.handleIdentifier(token, context);
     return token.next;
   }
 
+  Token ensureLiteralString(Token token) {
+    if (!identical(token.kind, STRING_TOKEN)) {
+      print('>>> ensureLiteralString');
+      reportRecoverableErrorCodeWithToken(token, codeExpectedString);
+      token = _rewriter.insertTokenBefore(
+          new SyntheticStringToken(TokenType.STRING, '""', token.offset, 0),
+          token);
+    }
+    return token;
+  }
+
   Token expect(String string, Token token) {
     if (!identical(string, token.stringValue)) {
       return reportUnrecoverableErrorCodeWithString(
               token, codeExpectedButGot, string)
           .next;
     }
     return token.next;
   }
 
   Token parseTypeVariable(Token token) {
@@ skipping 2927 matching lines @@
     return reportUnrecoverableError(
         token, () => code.format(uri, token.charOffset, string));
   }
 }
 
 typedef FastaMessage NoArgument(Uri uri, int charOffset);
 
 typedef FastaMessage TokenArgument(Uri uri, int charOffset, Token token);
 
 typedef FastaMessage StringArgument(Uri uri, int charOffset, String string);