improve handling of missing interpolation identifier

pkg/front_end/test/scanner_test.dart

 // Copyright (c) 2016, 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/base/errors.dart';
 import 'package:front_end/src/base/jenkins_smi_hash.dart';
 import 'package:front_end/src/scanner/errors.dart';
 import 'package:front_end/src/scanner/reader.dart';
 import 'package:front_end/src/scanner/scanner.dart';
 import 'package:front_end/src/scanner/token.dart';
@@ skipping 757 matching lines @@
 
   void test_minus_minus() {
     _assertToken(TokenType.MINUS_MINUS, "--");
   }
 
   void test_mismatched_closer() {
     // When openers and closers are mismatched, analyzer favors considering the
     // closer to be mismatched, which means that `(])` parses as a pair of
     // matched parentheses with an unmatched closing bracket between them.
     var openParen = _scan('(])') as BeginToken;
-    var closeBracket = openParen.next;
-    var closeParen = closeBracket.next;
-    expect(closeParen.next.type, TokenType.EOF);
-    expect(openParen.endToken, same(closeParen));
+    if (usingFasta) {
+      // When openers and closers are mismatched,
+      // fasta favors considering the opener to be mismatched,
+      // and inserts synthetic closers as needed.
+      // `(])` is parsed as `()])` where the first `)` is synthetic
+      // and the trailing `])` are unmatched.
+      var closeParen = openParen.next;
+      expect(closeParen.isSynthetic, isTrue);
+      var closeBracket = closeParen.next;
+      expect(closeBracket.isSynthetic, isFalse);
+      var closeParen2 = closeBracket.next;
+      expect(closeParen2.isSynthetic, isFalse);
+      expect(closeParen2.next.type, TokenType.EOF);
+      expect(openParen.endToken, same(closeParen));
+    } else {
+      var closeBracket = openParen.next;
+      var closeParen = closeBracket.next;
+      expect(closeParen.next.type, TokenType.EOF);
+      expect(openParen.endToken, same(closeParen));
+    }
   }
 
   void test_mismatched_opener() {
     // When openers and closers are mismatched, analyzer favors considering the
     // closer to be mismatched, which means that `([)` parses as three unmatched
     // tokens.
     var openParen = _scan('([)') as BeginToken;
     var openBracket = openParen.next as BeginToken;
-    var closeParen = openBracket.next;
-    expect(closeParen.next.type, TokenType.EOF);
-    expect(openParen.endToken, isNull);
-    expect(openBracket.endToken, isNull);
+    if (usingFasta) {
+      // When openers and closers are mismatched,
+      // fasta favors considering the opener to be mismatched
+      // and inserts synthetic closers as needed.
+      // `([)` is scanned as `([])` where `]` is synthetic.
+      var closeBracket = openBracket.next;
+      expect(closeBracket.isSynthetic, isTrue);
+      var closeParen = closeBracket.next;
+      expect(closeParen.isSynthetic, isFalse);
+      expect(closeParen.next.type, TokenType.EOF);
+      expect(openBracket.endToken, closeBracket);
+      expect(openParen.endToken, closeParen);
+    } else {
+      var closeParen = openBracket.next;
+      expect(closeParen.next.type, TokenType.EOF);
+      expect(openParen.endToken, isNull);
+      expect(openBracket.endToken, isNull);
+    }
   }
 
   void test_mismatched_opener_in_interpolation() {
     // In an interpolation expression, analyzer considers a closing `}` to
     // always match the preceding unmatched `{`, even if there are intervening
     // unmatched tokens, which means that `"${({(}}"` parses as though the open
     // parens are unmatched but everything else is matched.
     var stringStart = _scan(r'"${({(}}"');
     var interpolationStart = stringStart.next as BeginToken;
     var openParen1 = interpolationStart.next as BeginToken;
@@ skipping 372 matching lines @@
   void test_string_simple_interpolation_identifier() {
     _assertTokens("'Hello \$name!'", [
       new StringToken(TokenType.STRING, "'Hello ", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 7),
       new StringToken(TokenType.IDENTIFIER, "name", 8),
       new StringToken(TokenType.STRING, "!'", 12)
     ]);
   }
 
   void test_string_simple_interpolation_missingIdentifier() {
-    _assertTokens("'\$x\$'", [
+    var expectedTokens = <Token>[
       new StringToken(TokenType.STRING, "'", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
       new StringToken(TokenType.IDENTIFIER, "x", 2),
       new StringToken(TokenType.STRING, "", 3),
       new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 3),
-      new StringToken(TokenType.STRING, "'", 4)
-    ]);
+    ];
+    if (usingFasta) {
+      // Fasta scanner inserts a synthetic identifier
+      expectedTokens.addAll([
+        new SyntheticStringToken(TokenType.IDENTIFIER, "", 4, 0),
+        new StringToken(TokenType.STRING, "'", 4),
+      ]);
+    } else {
+      expectedTokens.addAll([
+        new StringToken(TokenType.STRING, "'", 4),
+      ]);
+    }
+    _assertTokens("'\$x\$'", expectedTokens);
   }
 
   void test_string_simple_interpolation_nonIdentifier() {
-    _assertTokens("'\$1'", [
+    var expectedTokens = <Token>[
       new StringToken(TokenType.STRING, "'", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
-      new StringToken(TokenType.STRING, "1'", 2)
+    ];
+    if (usingFasta) {
+      expectedTokens.addAll([
+        new SyntheticStringToken(TokenType.IDENTIFIER, "", 2),
+      ]);
+    }
+    expectedTokens.addAll([
+      new StringToken(TokenType.STRING, "1'", 2),
     ]);
+    _assertTokens("'\$1'", expectedTokens);
   }
 
   void test_string_simple_single() {
     _assertToken(TokenType.STRING, "'string'");
   }
 
   void test_string_simple_unterminated_eof() {
     String source = "'string";
     List<Token> expectedTokens = [];
     if (usingFasta) {
@@ skipping 401 matching lines @@
   _TestScanner(CharacterReader reader, [this.listener]) : super.create(reader);
 
   @override
   void reportError(
       ScannerErrorCode errorCode, int offset, List<Object> arguments) {
     if (listener != null) {
       listener.errors.add(new TestError(offset, errorCode, arguments));
     }
   }
 }