improve fasta closing brace recovery

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 761 matching lines @@
 
   void test_minus_eq() {
     _assertToken(TokenType.MINUS_EQ, "-=");
   }
 
   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.
+    // Normally when openers and closers are mismatched
+    // fasta favors considering the opener to be mismatched,
+    // and inserts synthetic closers as needed.
+    // In this particular case, fasta cannot find an opener for ']'
+    // and thus marks ']' as an error and moves on.
     ErrorListener listener = new ErrorListener();
     BeginToken openParen = scanWithListener('(])', listener);
+    var closeBracket = openParen.next;
+    var closeParen = closeBracket.next;
+    expect(closeParen.next.type, TokenType.EOF);
+    expect(openParen.endToken, same(closeParen));
+    listener.assertNoErrors();
+  }
+
+  void test_mismatched_closer2() {
+    // When openers and closers are mismatched, analyzer favors considering the
+    // closer to be mismatched, which means that `[(])` parses as a pair of
+    // matched parenthesis with an unmatched open bracket before them
+    // and an unmatched closing bracket between them.
+    ErrorListener listener = new ErrorListener();
+    BeginToken openBracket = scanWithListener('[(])', listener);
+    BeginToken openParen = openBracket.next;
     if (usingFasta) {
-      // When openers and closers are mismatched,
+      // 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.
+      // `[(])` is parsed as `[()])` where the first `)` is synthetic
+      // and the trailing `)` is 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(openBracket.endToken, same(closeBracket));
       expect(openParen.endToken, same(closeParen));
       listener.assertErrors([
-        new TestError(0, ScannerErrorCode.EXPECTED_TOKEN, [')']),
+        new TestError(1, ScannerErrorCode.EXPECTED_TOKEN, [')']),
       ]);
     } else {
       var closeBracket = openParen.next;
       var closeParen = closeBracket.next;
       expect(closeParen.next.type, TokenType.EOF);
+      expect(openBracket.endToken, isNull);
       expect(openParen.endToken, same(closeParen));
       listener.assertNoErrors();
     }
   }
 
   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.
     ErrorListener listener = new ErrorListener();
@@ skipping 901 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));
     }
   }
 }