improve fasta export directive 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 Code, Message, Template;
 
 import '../fasta_codes.dart' as fasta;
 
 import '../scanner.dart' show ErrorToken, Token;
 
 import '../scanner/recover.dart' show closeBraceFor, skipToEof;
 
 import '../../scanner/token.dart'
     show
         ASSIGNMENT_PRECEDENCE,
         BeginToken,
         CASCADE_PRECEDENCE,
         EQUALITY_PRECEDENCE,
         POSTFIX_PRECEDENCE,
         RELATIONAL_PRECEDENCE,
+        SyntheticStringToken,
+        SyntheticToken,
         TokenType;
 
 import '../scanner/token.dart' show isUserDefinableOperator;
 
 import '../scanner/token_constants.dart'
     show
         COMMA_TOKEN,
         DOUBLE_TOKEN,
         EOF_TOKEN,
         EQ_TOKEN,
@@ skipping 28 matching lines @@
         FormalParameterKind,
         isMandatoryFormalParameterKind,
         isOptionalPositionalFormalParameterKind;
 
 import 'identifier_context.dart' show IdentifierContext;
 
 import 'listener.dart' show Listener;
 
 import 'member_kind.dart' show MemberKind;
 
+import 'token_stream_rewriter.dart';
+
 import 'type_continuation.dart'
     show TypeContinuation, typeContiunationFromFormalParameterKind;
 
 import 'util.dart' show closeBraceTokenFor, optional;
 
 /// An event generating parser of Dart programs. This parser expects all tokens
 /// in a linked list (aka a token stream).
 ///
 /// The class [Scanner] is used to generate a token stream. See the file
 /// [scanner.dart](../scanner.dart).
@@ skipping 120 matching lines @@
 
   Uri get uri => listener.uri;
 
   bool mayParseFunctionExpressions = true;
 
   /// 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;
 
+  /// The first token in the parse stream and used during parser recovery.
+  /// This is automatically set by the [parseUnit] method,
+  /// but must be manually set when any other parse method is called.
+  /// If not set, then the parser will call [handleUnrecoverableError]
+  /// rather than rewriting the token stream
+  /// and calling [handleRecoverableError].
+  Token firstToken;
+
+  /// A rewriter for inserting synthetic tokens.
+  /// Access using [rewriter] for lazy initialization.
+  TokenStreamRewriter cachedRewriter;
+
+  TokenStreamRewriter get rewriter {
+    assert(firstToken != null, 'firstToken must be set for parser recovery');
+    cachedRewriter ??= new TokenStreamRewriter(firstToken);
+    return cachedRewriter;
+  }
+
   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) {
+    firstToken = token;
     listener.beginCompilationUnit(token);
     int count = 0;
     while (!identical(token.kind, EOF_TOKEN)) {
       token = parseTopLevelDeclaration(token);
       count++;
     }
     listener.endCompilationUnit(count, token);
+    // Clear fields that could lead to memory leak.
+    firstToken = null;
+    cachedRewriter = null;
     return token;
   }
 
   Token parseTopLevelDeclaration(Token token) {
     token = _parseTopLevelDeclaration(token);
     listener.endTopLevelDeclaration(token);
     return token;
   }
 
   Token _parseTopLevelDeclaration(Token token) {
@@ skipping 106 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 = ensureParseLiteralString(token.next);
     token = parseConditionalUris(token);
     token = parseCombinators(token);
-    Token semicolon = token;
-    token = expect(';', token);
+    Token semicolon = ensureSemicolon(token);
     listener.endExport(exportKeyword, semicolon);
-    return token;
+    return semicolon.next;
   }
 
   Token parseCombinators(Token token) {
     listener.beginCombinators(token);
     int count = 0;
     while (true) {
       String value = token.stringValue;
       if (identical('hide', value)) {
         token = parseHide(token);
       } else if (identical('show', value)) {
@@ skipping 521 matching lines @@
         reportRecoverableError(token, fasta.messageYieldAsIdentifier);
       } else if (optional('async', token)) {
         reportRecoverableError(token, fasta.messageAsyncAsIdentifier);
       }
     }
     listener.handleIdentifier(token, context);
     return token.next;
   }
 
   Token expect(String string, Token token) {
+    // TODO(danrubel) update all uses of expect(';'...) to ensureSemicolon
+    // then add assert(!identical(';', string));
     if (!identical(string, token.stringValue)) {
       return reportUnrecoverableError(
               token, fasta.templateExpectedButGot.withArguments(string))
           .next;
     }
     return token.next;
   }
 
   Token parseTypeVariable(Token token) {
     listener.beginTypeVariable(token);
@@ skipping 998 matching lines @@
     listener.beginInitializer(token);
     if (optional('assert', token)) {
       token = parseAssert(token, Assert.Initializer);
     } else {
       token = parseExpression(token);
     }
     listener.endInitializer(token);
     return token;
   }
 
+  Token ensureParseLiteralString(Token token) {
+    if (!identical(token.kind, STRING_TOKEN)) {
+      Message message = fasta.templateExpectedString.withArguments(token);
+      Token newToken =
+          new SyntheticStringToken(TokenType.STRING, '""', token.charOffset, 0);
+      token = rewriteAndRecover(token, message, newToken);
+    }
+    return parseLiteralString(token);
+  }
+
+  Token ensureSemicolon(Token token) {
+    // TODO(danrubel): Once all expect(';'...) call sites have been converted
+    // to use this method, remove similar semicolon recovery code
+    // from the handleError method in element_listener.dart.
+    if (optional(';', token)) return token;
+    Message message = fasta.templateExpectedButGot.withArguments(';');
+    Token newToken = new SyntheticToken(TokenType.SEMICOLON, token.charOffset);
+    return rewriteAndRecover(token, message, newToken);
+  }
+
+  Token rewriteAndRecover(Token token, Message message, Token newToken) {
+    if (firstToken == null) return reportUnrecoverableError(token, message);
+    reportRecoverableError(token, message);
+    token = rewriter.insertTokenBefore(newToken, token);
+    return token;
+  }
+
   Token parseLiteralStringOrRecoverExpression(Token token) {
     if (identical(token.kind, STRING_TOKEN)) {
       return parseLiteralString(token);
     } else if (token is ErrorToken) {
       return reportErrorToken(token, false);
     } else {
       reportRecoverableErrorWithToken(token, fasta.templateExpectedString);
       return parseRecoverExpression(
           token, fasta.templateExpectedString.withArguments(token));
     }
@@ skipping 2130 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);