translate remaining fasta scanner error codes

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 417 matching lines @@
     _assertError(ScannerErrorCode.ILLEGAL_CHARACTER, 0, "\u0312", [0x312]);
   }
 
   void test_incomplete_string_interpolation() {
     // https://code.google.com/p/dart/issues/detail?id=18073
     List<Token> expectedTokens = [
       new StringToken(TokenType.STRING, "\"foo ", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 5),
       new StringToken(TokenType.IDENTIFIER, "bar", 7),
     ];
+    var expectedErrors = [
+      new TestError(9, ScannerErrorCode.UNTERMINATED_STRING_LITERAL, null),
+    ];
     if (usingFasta) {
       // fasta inserts synthetic closers
       expectedTokens.addAll([
         new SyntheticToken(TokenType.CLOSE_CURLY_BRACKET, 10),
         new SyntheticStringToken(TokenType.STRING, "\"", 10, 0),
       ]);
+      expectedErrors.addAll([
+        new TestError(5, ScannerErrorCode.EXPECTED_TOKEN, ['}']),
+      ]);
     } else {
       expectedTokens.addAll([
         new StringToken(TokenType.STRING, "", 10),
       ]);
     }
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 9,
-        "\"foo \${bar", expectedTokens);
+    ErrorListener listener = new ErrorListener();
+    Token token = scanWithListener("\"foo \${bar", listener);
+    listener.assertErrors(expectedErrors);
+    _checkTokens(token, expectedTokens);
   }
 
   void test_index() {
     _assertToken(TokenType.INDEX, "[]");
   }
 
   void test_index_eq() {
     _assertToken(TokenType.INDEX_EQ, "[]=");
   }
 
@@ skipping 251 matching lines @@
 
   void test_lt_lt() {
     _assertToken(TokenType.LT_LT, "<<");
   }
 
   void test_lt_lt_eq() {
     _assertToken(TokenType.LT_LT_EQ, "<<=");
   }
 
   void test_matching_braces() {
-    var openBrace1 = _scan('{1: {2: 3}}') as BeginToken;
+    BeginToken openBrace1 = _scan('{1: {2: 3}}');
     var one = openBrace1.next;
     var colon1 = one.next;
-    var openBrace2 = colon1.next as BeginToken;
+    BeginToken openBrace2 = colon1.next;
     var two = openBrace2.next;
     var colon2 = two.next;
     var three = colon2.next;
     var closeBrace1 = three.next;
     var closeBrace2 = closeBrace1.next;
     expect(closeBrace2.next.type, TokenType.EOF);
     expect(openBrace1.endToken, same(closeBrace2));
     expect(openBrace2.endToken, same(closeBrace1));
   }
 
   void test_matching_brackets() {
-    var openBracket1 = _scan('[1, [2]]') as BeginToken;
+    BeginToken openBracket1 = _scan('[1, [2]]');
     var one = openBracket1.next;
     var comma = one.next;
-    var openBracket2 = comma.next as BeginToken;
+    BeginToken openBracket2 = comma.next;
     var two = openBracket2.next;
     var closeBracket1 = two.next;
     var closeBracket2 = closeBracket1.next;
     expect(closeBracket2.next.type, TokenType.EOF);
     expect(openBracket1.endToken, same(closeBracket2));
     expect(openBracket2.endToken, same(closeBracket1));
   }
 
   void test_matching_parens() {
-    var openParen1 = _scan('(f(x))') as BeginToken;
+    BeginToken openParen1 = _scan('(f(x))');
     var f = openParen1.next;
-    var openParen2 = f.next as BeginToken;
+    BeginToken openParen2 = f.next;
     var x = openParen2.next;
     var closeParen1 = x.next;
     var closeParen2 = closeParen1.next;
     expect(closeParen2.next.type, TokenType.EOF);
     expect(openParen1.endToken, same(closeParen2));
     expect(openParen2.endToken, same(closeParen1));
   }
 
   void test_minus() {
     _assertToken(TokenType.MINUS, "-");
   }
 
   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.
-    var openParen = _scan('(])') as BeginToken;
+    ErrorListener listener = new ErrorListener();
+    BeginToken openParen = scanWithListener('(])', listener);
     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));
+      listener.assertErrors([
+        new TestError(0, ScannerErrorCode.EXPECTED_TOKEN, [')']),
+      ]);
     } else {
       var closeBracket = openParen.next;
       var closeParen = closeBracket.next;
       expect(closeParen.next.type, TokenType.EOF);
       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.
-    var openParen = _scan('([)') as BeginToken;
-    var openBracket = openParen.next as BeginToken;
+    ErrorListener listener = new ErrorListener();
+    BeginToken openParen = scanWithListener('([)', listener);
+    BeginToken openBracket = openParen.next;
     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);
+      listener.assertErrors([
+        new TestError(1, ScannerErrorCode.EXPECTED_TOKEN, [']']),
+      ]);
     } else {
       var closeParen = openBracket.next;
       expect(closeParen.next.type, TokenType.EOF);
       expect(openParen.endToken, isNull);
       expect(openBracket.endToken, isNull);
+      listener.assertNoErrors();
     }
   }
 
   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;
-    var openBrace = openParen1.next as BeginToken;
-    var openParen2 = openBrace.next as BeginToken;
+    BeginToken interpolationStart = stringStart.next;
+    BeginToken openParen1 = interpolationStart.next;
+    BeginToken openBrace = openParen1.next;
+    BeginToken openParen2 = openBrace.next;
     var closeBrace = openParen2.next;
     var interpolationEnd = closeBrace.next;
     var stringEnd = interpolationEnd.next;
     expect(stringEnd.next.type, TokenType.EOF);
     expect(interpolationStart.endToken, same(interpolationEnd));
     expect(openParen1.endToken, isNull);
     expect(openBrace.endToken, same(closeBrace));
     expect(openParen2.endToken, isNull);
   }
 
@@ skipping 189 matching lines @@
       ]);
     }
   }
 
   void test_string_multi_unterminated_interpolation_block() {
     List<Token> expectedTokens = [
       new StringToken(TokenType.STRING, "'''", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 3),
       new StringToken(TokenType.IDENTIFIER, "name", 5),
     ];
+    var expectedErrors = [
+      new TestError(8, ScannerErrorCode.UNTERMINATED_STRING_LITERAL, null),
+    ];
     if (usingFasta) {
       // fasta inserts synthetic closers
       expectedTokens.addAll([
         new SyntheticToken(TokenType.CLOSE_CURLY_BRACKET, 9),
         new SyntheticStringToken(TokenType.STRING, "'''", 9, 0),
       ]);
+      expectedErrors.addAll([
+        new TestError(3, ScannerErrorCode.EXPECTED_TOKEN, ['}']),
+      ]);
     } else {
       expectedTokens.addAll([
         new StringToken(TokenType.STRING, "", 9),
       ]);
     }
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8,
-        "'''\${name", expectedTokens);
+    ErrorListener listener = new ErrorListener();
+    Token token = scanWithListener("'''\${name", listener);
+    listener.assertErrors(expectedErrors);
+    _checkTokens(token, expectedTokens);
   }
 
   void test_string_multi_unterminated_interpolation_identifier() {
     List<Token> expectedTokens = [
       new StringToken(TokenType.STRING, "'''", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 3),
       new StringToken(TokenType.IDENTIFIER, "name", 4),
     ];
     if (usingFasta) {
       // fasta inserts synthetic closers
@@ skipping 145 matching lines @@
   }
 
   void test_string_simple_interpolation_missingIdentifier() {
     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),
     ];
+    var expectedErrors = [];
     if (usingFasta) {
       // Fasta scanner inserts a synthetic identifier
       expectedTokens.addAll([
         new SyntheticStringToken(TokenType.IDENTIFIER, "", 4, 0),
         new StringToken(TokenType.STRING, "'", 4),
       ]);
+      expectedErrors.addAll([
+        new TestError(4, ScannerErrorCode.MISSING_IDENTIFIER, null),
+      ]);
     } else {
       expectedTokens.addAll([
         new StringToken(TokenType.STRING, "'", 4),
       ]);
     }
-    _assertTokens("'\$x\$'", expectedTokens);
+    ErrorListener listener = new ErrorListener();
+    Token token = scanWithListener("'\$x\$'", listener);
+    listener.assertErrors(expectedErrors);
+    _checkTokens(token, expectedTokens);
   }
 
   void test_string_simple_interpolation_nonIdentifier() {
     var expectedTokens = <Token>[
       new StringToken(TokenType.STRING, "'", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
     ];
+    var expectedErrors = [];
     if (usingFasta) {
       expectedTokens.addAll([
         new SyntheticStringToken(TokenType.IDENTIFIER, "", 2),
       ]);
+      expectedErrors.addAll([
+        new TestError(2, ScannerErrorCode.MISSING_IDENTIFIER, null),
+      ]);
     }
     expectedTokens.addAll([
       new StringToken(TokenType.STRING, "1'", 2),
     ]);
-    _assertTokens("'\$1'", expectedTokens);
+    ErrorListener listener = new ErrorListener();
+    Token token = scanWithListener("'\$1'", listener);
+    listener.assertErrors(expectedErrors);
+    _checkTokens(token, 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 26 matching lines @@
     _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
         usingFasta ? 6 : 7, source, expectedTokens);
   }
 
   void test_string_simple_unterminated_interpolation_block() {
     List<Token> expectedTokens = [
       new StringToken(TokenType.STRING, "'", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 1),
       new StringToken(TokenType.IDENTIFIER, "name", 3),
     ];
+    List<TestError> expectedErrors = [
+      new TestError(6, ScannerErrorCode.UNTERMINATED_STRING_LITERAL, null),
+    ];
     if (usingFasta) {
       // fasta inserts synthetic closers
       expectedTokens.addAll([
         new SyntheticToken(TokenType.CLOSE_CURLY_BRACKET, 7),
         new SyntheticStringToken(TokenType.STRING, "'", 7, 0),
       ]);
+      expectedErrors.addAll([
+        new TestError(1, ScannerErrorCode.EXPECTED_TOKEN, ['}']),
+      ]);
     } else {
       expectedTokens.addAll([
         new StringToken(TokenType.STRING, "", 7),
       ]);
     }
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 6,
-        "'\${name", expectedTokens);
+    ErrorListener listener = new ErrorListener();
+    Token token = scanWithListener("'\${name", listener);
+    listener.assertErrors(expectedErrors);
+    _checkTokens(token, expectedTokens);
   }
 
   void test_string_simple_unterminated_interpolation_identifier() {
     List<Token> expectedTokens = [
       new StringToken(TokenType.STRING, "'", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 1),
       new StringToken(TokenType.IDENTIFIER, "name", 2),
     ];
     if (usingFasta) {
       // fasta inserts synthetic closers
@@ skipping 28 matching lines @@
   void test_tilde_slash_eq() {
     _assertToken(TokenType.TILDE_SLASH_EQ, "~/=");
   }
 
   void test_unclosedPairInInterpolation() {
     ErrorListener listener = new ErrorListener();
     scanWithListener("'\${(}'", listener);
   }
 
   void test_unmatched_openers() {
-    var openBrace = _scan('{[(') as BeginToken;
-    var openBracket = openBrace.next as BeginToken;
-    var openParen = openBracket.next as BeginToken;
+    BeginToken openBrace = _scan('{[(');
+    BeginToken openBracket = openBrace.next;
+    BeginToken openParen = openBracket.next;
     expect(openParen.next.type, TokenType.EOF);
     expect(openBrace.endToken, isNull);
     expect(openBracket.endToken, isNull);
     expect(openParen.endToken, isNull);
   }
 
   void _assertComment(TokenType commentType, String source,
       {bool genericMethodComments: false}) {
     //
     // Test without a trailing end-of-line marker
@@ skipping 80 matching lines @@
     expect((value as Keyword).lexeme, source);
     expect(token.next.type, TokenType.EOF);
   }
 
   /**
    * Assert that the token scanned from the given [source] has the
    * [expectedType].
    */
   Token _assertToken(TokenType expectedType, String source,
       {bool lazyAssignmentOperators: false}) {
-    Token originalToken =
-        _scan(source, lazyAssignmentOperators: lazyAssignmentOperators);
+    // Fasta generates errors for unmatched '{', '[', etc
+    Token originalToken = _scan(source,
+        lazyAssignmentOperators: lazyAssignmentOperators,
+        ignoreErrors: usingFasta);
     expect(originalToken, isNotNull);
     expect(originalToken.type, expectedType);
     expect(originalToken.offset, 0);
     expect(originalToken.length, source.length);
     expect(originalToken.lexeme, source);
     if (expectedType == TokenType.SCRIPT_TAG) {
       // Adding space before the script tag is not allowed, and adding text at
       // the end changes nothing.
       return originalToken;
     } else if (expectedType == TokenType.SINGLE_LINE_COMMENT) {
       // Adding space to an end-of-line comment changes the comment.
-      Token tokenWithSpaces =
-          _scan(" $source", lazyAssignmentOperators: lazyAssignmentOperators);
+      Token tokenWithSpaces = _scan(" $source",
+          lazyAssignmentOperators: lazyAssignmentOperators,
+          ignoreErrors: usingFasta);
       expect(tokenWithSpaces, isNotNull);
       expect(tokenWithSpaces.type, expectedType);
       expect(tokenWithSpaces.offset, 1);
       expect(tokenWithSpaces.length, source.length);
       expect(tokenWithSpaces.lexeme, source);
       return originalToken;
     } else if (expectedType == TokenType.INT ||
         expectedType == TokenType.DOUBLE) {
-      Token tokenWithLowerD =
-          _scan("${source}d", lazyAssignmentOperators: lazyAssignmentOperators);
+      Token tokenWithLowerD = _scan("${source}d",
+          lazyAssignmentOperators: lazyAssignmentOperators,
+          ignoreErrors: usingFasta);
       expect(tokenWithLowerD, isNotNull);
       expect(tokenWithLowerD.type, expectedType);
       expect(tokenWithLowerD.offset, 0);
       expect(tokenWithLowerD.length, source.length);
       expect(tokenWithLowerD.lexeme, source);
-      Token tokenWithUpperD =
-          _scan("${source}D", lazyAssignmentOperators: lazyAssignmentOperators);
+      Token tokenWithUpperD = _scan("${source}D",
+          lazyAssignmentOperators: lazyAssignmentOperators,
+          ignoreErrors: usingFasta);
       expect(tokenWithUpperD, isNotNull);
       expect(tokenWithUpperD.type, expectedType);
       expect(tokenWithUpperD.offset, 0);
       expect(tokenWithUpperD.length, source.length);
       expect(tokenWithUpperD.lexeme, source);
     }
-    Token tokenWithSpaces =
-        _scan(" $source ", lazyAssignmentOperators: lazyAssignmentOperators);
+    Token tokenWithSpaces = _scan(" $source ",
+        lazyAssignmentOperators: lazyAssignmentOperators,
+        ignoreErrors: usingFasta);
     expect(tokenWithSpaces, isNotNull);
     expect(tokenWithSpaces.type, expectedType);
     expect(tokenWithSpaces.offset, 1);
     expect(tokenWithSpaces.length, source.length);
     expect(tokenWithSpaces.lexeme, source);
 
     // Fasta inserts missing closers (']', '}', ')')
     //expect(originalToken.next.type, TokenType.EOF);
     return originalToken;
   }
@@ skipping 20 matching lines @@
       expect(token.lexeme, expectedToken.lexeme,
           reason: "Wrong lexeme for token $i");
       token = token.next;
       expect(token, isNotNull);
     }
     expect(token.type, TokenType.EOF);
   }
 
   Token _scan(String source,
       {bool genericMethodComments: false,
-      bool lazyAssignmentOperators: false}) {
+      bool lazyAssignmentOperators: false,
+      bool ignoreErrors: false}) {
     ErrorListener listener = new ErrorListener();
     Token token = scanWithListener(source, listener,
         genericMethodComments: genericMethodComments,
         lazyAssignmentOperators: lazyAssignmentOperators);
-    listener.assertNoErrors();
+    if (!ignoreErrors) {
+      listener.assertNoErrors();
+    }
     return token;
   }
 }
 
 class TestError {
   final int offset;
   final ErrorCode errorCode;
   final List<Object> arguments;
 
   TestError(this.offset, this.errorCode, this.arguments);
@@ skipping 105 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));
     }
   }
 }