translate remaining fasta scanner error codes

pkg/front_end/test/scanner_replacement_test.dart

 // Copyright (c) 2017, 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 'dart:convert' show UTF8;
 
 import 'package:front_end/src/fasta/scanner/recover.dart'
     show defaultRecoveryStrategy;
 import 'package:front_end/src/fasta/scanner.dart' as fasta;
 import 'package:front_end/src/fasta/scanner/token.dart' as fasta;
@@ skipping 59 matching lines @@
 
   void _assertOpenClosePair(String source) {
     analyzer.BeginToken open = _scan(source);
     fasta.Token close = open.next;
     expect(close.next.isEof, isTrue);
     expect(open.endGroup, close);
     expect(open.isSynthetic, isFalse);
     expect(close.isSynthetic, isFalse);
   }
 
-  void _assertOpenOnly(String source) {
-    analyzer.BeginToken open = _scan(source);
+  void _assertOpenOnly(String source, String expectedCloser) {
+    ErrorListener listener = new ErrorListener();
+    analyzer.BeginToken open = scanWithListener(source, listener);
     fasta.Token close = open.next;
     expect(close.next.isEof, isTrue);
     expect(open.endGroup, close);
     expect(open.isSynthetic, isFalse);
     expect(close.isSynthetic, isTrue);
+    listener.assertErrors([
+      new TestError(0, ScannerErrorCode.EXPECTED_TOKEN, [expectedCloser]),
+    ]);
   }
 
   void test_lt() {
     // fasta does not automatically insert a closer for '<'
     // because it could be part of an expression rather than an opener
     analyzer.BeginToken lt = _scan('<');
     expect(lt.next.isEof, isTrue);
     expect(lt.isSynthetic, isFalse);
   }
 
   void test_lt_gt() {
     _assertOpenClosePair('< >');
   }
 
   @override
   void test_open_curly_bracket() {
-    _assertOpenOnly('{');
+    _assertOpenOnly('{', '}');
   }
 
   void test_open_curly_bracket_with_close() {
     _assertOpenClosePair('{ }');
   }
 
   void test_open_paren() {
-    _assertOpenOnly('(');
+    _assertOpenOnly('(', ')');
   }
 
   void test_open_paren_with_close() {
     _assertOpenClosePair('( )');
   }
 
   void test_open_square_bracket() {
-    _assertOpenOnly('[');
+    _assertOpenOnly('[', ']');
   }
 
   void test_open_square_bracket_with_close() {
     _assertOpenClosePair('[ ]');
   }
 
   @override
   void test_mismatched_opener_in_interpolation() {
     // When openers and closers are mismatched,
     // fasta favors considering the opener to be mismatched
     // and inserts synthetic closers as needed.
     // r'"${({(}}"' is parsed as r'"${({()})}"'
     // where both ')' are synthetic
-    var stringStart = _scan(r'"${({(}}"');
-    var interpolationStart = stringStart.next as analyzer.BeginToken;
-    var openParen1 = interpolationStart.next as analyzer.BeginToken;
-    var openBrace = openParen1.next as analyzer.BeginToken;
-    var openParen2 = openBrace.next as analyzer.BeginToken;
+    ErrorListener listener = new ErrorListener();
+    var stringStart = scanWithListener(r'"${({(}}"', listener);
+    analyzer.BeginToken interpolationStart = stringStart.next;
+    analyzer.BeginToken openParen1 = interpolationStart.next;
+    analyzer.BeginToken openBrace = openParen1.next;
+    analyzer.BeginToken openParen2 = openBrace.next;
     var closeParen2 = openParen2.next;
     var closeBrace = closeParen2.next;
     var closeParen1 = closeBrace.next;
     var interpolationEnd = closeParen1.next;
     var stringEnd = interpolationEnd.next;
     var eof = stringEnd.next;
 
     expect(interpolationStart.endToken, same(interpolationEnd));
     expect(interpolationEnd.isSynthetic, isFalse);
     expect(openParen1.endToken, same(closeParen1));
     expect(closeParen1.isSynthetic, isTrue);
     expect(openBrace.endToken, same(closeBrace));
     expect(closeBrace.isSynthetic, isFalse);
     expect(openParen2.endToken, same(closeParen2));
     expect(closeParen2.isSynthetic, isTrue);
     expect(eof.isEof, isTrue);
+    listener.assertErrors([
+      new TestError(3, ScannerErrorCode.EXPECTED_TOKEN, [')']),
+      new TestError(5, ScannerErrorCode.EXPECTED_TOKEN, [')']),
+    ]);
   }
 
   @override
   void test_unmatched_openers() {
+    ErrorListener listener = new ErrorListener();
     // fasta inserts missing closers except for '<'
-    var openBrace = _scan('{[(<') as analyzer.BeginToken;
-    var openBracket = openBrace.next as analyzer.BeginToken;
-    var openParen = openBracket.next as analyzer.BeginToken;
-    var openLT = openParen.next as analyzer.BeginToken;
+    analyzer.BeginToken openBrace = scanWithListener('{[(<', listener);
+    analyzer.BeginToken openBracket = openBrace.next;
+    analyzer.BeginToken openParen = openBracket.next;
+    analyzer.BeginToken openLT = openParen.next;
     var closeParen = openLT.next;
     var closeBracket = closeParen.next;
     var closeBrace = closeBracket.next;
     var eof = closeBrace.next;
 
     expect(openBrace.endGroup, same(closeBrace));
     expect(openBracket.endGroup, same(closeBracket));
     expect(openParen.endGroup, same(closeParen));
     expect(eof.isEof, true);
+
+    listener.assertErrors([
+      new TestError(2, ScannerErrorCode.EXPECTED_TOKEN, [')']),
+      new TestError(1, ScannerErrorCode.EXPECTED_TOKEN, [']']),
+      new TestError(0, ScannerErrorCode.EXPECTED_TOKEN, ['}']),
+    ]);
   }
 
   analyzer.Token _scan(String source,
       {bool genericMethodComments: false,
       bool lazyAssignmentOperators: false}) {
     ErrorListener listener = new ErrorListener();
     analyzer.Token token = scanWithListener(source, listener,
         genericMethodComments: genericMethodComments,
         lazyAssignmentOperators: lazyAssignmentOperators);
     listener.assertNoErrors();
@@ skipping 62 matching lines @@
       } else if (token is fasta.UnmatchedToken) {
         expect(lastClosedGroup?.endGroup?.next, same(token),
             reason: 'Unexpected error token for group: $lastClosedGroup');
         expect(token.begin, lastClosedGroup);
       }
       token = token.next;
     }
     expect(openerStack, isEmpty, reason: 'Missing closers');
   }
 }