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 316 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 1539 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)) {

[ahe, 2017/08/21 12:51:37]

Don't need to use identical on int.

[danrubel, 2017/08/21 14:51:02]

Fair enough. I was just following what you already did on line 1945 below.

+      reportRecoverableErrorWithToken(token, fasta.templateExpectedString);
+      token = listener.rewriter.insertTokenBefore(

[ahe, 2017/08/21 12:51:37]

Something is off here. If the parser does the rewriting, it doesn't make sense
that the listener holds the rewriter.

[danrubel, 2017/08/21 14:51:02]

Yeah. I had the parser holding onto the rewriter but was asked to move it into
the listener. It makes sense for the parser to do the recovery because otherwise
various listeners will recover differently, which will produce different error
messages and different generated code for different listeners and confuse the
user.

+          new SyntheticStringToken(TokenType.STRING, '""', token.charOffset, 0),
+          token);
+    }
+    return parseLiteralString(token);
+  }
+
+  Token ensureSemicolon(Token token) {
+    if (optional(';', token)) return token;
+    reportRecoverableError(
+        token, fasta.templateExpectedButGot.withArguments(';'));
+    return listener.rewriter.insertTokenBefore(
+        new SyntheticToken(TokenType.SEMICOLON, token.charOffset), 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);