Fix line info for multi-line strings (issue 22794)

pkg/analyzer/test/generated/scanner_test.dart

 // Copyright (c) 2014, 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 engine.scanner_test;
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
 import 'test_support.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(CharSequenceReaderTest);
   runReflectiveTests(KeywordStateTest);
   runReflectiveTests(ScannerTest);
   runReflectiveTests(TokenTypeTest);
 }
 
-@reflectiveTest
-class CharSequenceReaderTest {
-  void test_advance() {
-    CharSequenceReader reader = new CharSequenceReader("x");
-    expect(reader.advance(), 0x78);
-    expect(reader.advance(), -1);
-    expect(reader.advance(), -1);
-  }
-
-  void test_creation() {
-    expect(new CharSequenceReader("x"), isNotNull);
-  }
-
-  void test_getOffset() {
-    CharSequenceReader reader = new CharSequenceReader("x");
-    expect(reader.offset, -1);
-    reader.advance();
-    expect(reader.offset, 0);
-    reader.advance();
-    expect(reader.offset, 0);
-  }
-
-  void test_getString() {
-    CharSequenceReader reader = new CharSequenceReader("xyzzy");
-    reader.offset = 3;
-    expect(reader.getString(1, 0), "yzz");
-    expect(reader.getString(2, 1), "zzy");
-  }
-
-  void test_peek() {
-    CharSequenceReader reader = new CharSequenceReader("xy");
-    expect(reader.peek(), 0x78);
-    expect(reader.peek(), 0x78);
-    reader.advance();
-    expect(reader.peek(), 0x79);
-    expect(reader.peek(), 0x79);
-    reader.advance();
-    expect(reader.peek(), -1);
-    expect(reader.peek(), -1);
-  }
-
-  void test_setOffset() {
-    CharSequenceReader reader = new CharSequenceReader("xyz");
-    reader.offset = 2;
-    expect(reader.offset, 2);
-  }
-}
-
 class CharacterRangeReaderTest extends EngineTestCase {
   void test_advance() {
     CharSequenceReader baseReader = new CharSequenceReader("xyzzy");
     CharacterRangeReader reader = new CharacterRangeReader(baseReader, 1, 4);
     expect(reader.advance(), 0x79);
     expect(reader.advance(), 0x80);
     expect(reader.advance(), 0x80);
     expect(reader.advance(), -1);
     expect(reader.advance(), -1);
   }
@@ skipping 34 matching lines @@
     expect(reader.peek(), -1);
     expect(reader.peek(), -1);
   }
 
   void test_setOffset() {
     CharSequenceReader baseReader = new CharSequenceReader("xyzzy");
     CharacterRangeReader reader = new CharacterRangeReader(baseReader, 1, 4);
     reader.offset = 2;
     expect(reader.offset, 2);
   }
+}
+
+@reflectiveTest
+class CharSequenceReaderTest {
+  void test_advance() {
+    CharSequenceReader reader = new CharSequenceReader("x");
+    expect(reader.advance(), 0x78);
+    expect(reader.advance(), -1);
+    expect(reader.advance(), -1);
+  }
+
+  void test_creation() {
+    expect(new CharSequenceReader("x"), isNotNull);
+  }
+
+  void test_getOffset() {
+    CharSequenceReader reader = new CharSequenceReader("x");
+    expect(reader.offset, -1);
+    reader.advance();
+    expect(reader.offset, 0);
+    reader.advance();
+    expect(reader.offset, 0);
+  }
+
+  void test_getString() {
+    CharSequenceReader reader = new CharSequenceReader("xyzzy");
+    reader.offset = 3;
+    expect(reader.getString(1, 0), "yzz");
+    expect(reader.getString(2, 1), "zzy");
+  }
+
+  void test_peek() {
+    CharSequenceReader reader = new CharSequenceReader("xy");
+    expect(reader.peek(), 0x78);
+    expect(reader.peek(), 0x78);
+    reader.advance();
+    expect(reader.peek(), 0x79);
+    expect(reader.peek(), 0x79);
+    reader.advance();
+    expect(reader.peek(), -1);
+    expect(reader.peek(), -1);
+  }
+
+  void test_setOffset() {
+    CharSequenceReader reader = new CharSequenceReader("xyz");
+    reader.offset = 2;
+    expect(reader.offset, 2);
+  }
 }
 
 @reflectiveTest
 class KeywordStateTest {
   void test_KeywordState() {
     //
     // Generate the test data to be scanned.
     //
     List<Keyword> keywords = Keyword.values;
     int keywordCount = keywords.length;
@@ skipping 451 matching lines @@
 
   void test_lineInfo_multilineString() {
     String source = "'''a\r\nbc\r\nd'''";
     _assertLineInfo(source, [
       new ScannerTest_ExpectedLocation(0, 1, 1),
       new ScannerTest_ExpectedLocation(7, 2, 2),
       new ScannerTest_ExpectedLocation(source.length - 1, 3, 4)
     ]);
   }
 
+  void test_lineInfo_multilineString_raw() {
+    String source = "var a = r'''\nblah\n''';\n\nfoo";
+    _assertLineInfo(source, [
+      new ScannerTest_ExpectedLocation(0, 1, 1),
+      new ScannerTest_ExpectedLocation(14, 2, 2),
+      new ScannerTest_ExpectedLocation(source.length - 2, 5, 2)
+    ]);
+  }
+
   void test_lineInfo_simpleClass() {
     String source =
         "class Test {\r\n    String s = '...';\r\n    int get x => s.MISSING_GETTER;\r\n}";
     _assertLineInfo(source, [
       new ScannerTest_ExpectedLocation(0, 1, 1),
       new ScannerTest_ExpectedLocation(source.indexOf("MISSING_GETTER"), 3, 20),
       new ScannerTest_ExpectedLocation(source.length - 1, 4, 1)
     ]);
   }
 
@@ skipping 26 matching lines @@
   }
 
   void test_minus_eq() {
     _assertToken(TokenType.MINUS_EQ, "-=");
   }
 
   void test_minus_minus() {
     _assertToken(TokenType.MINUS_MINUS, "--");
   }
 
-  void test_openSquareBracket() {
-    _assertToken(TokenType.OPEN_SQUARE_BRACKET, "[");
-  }
-
   void test_open_curly_bracket() {
     _assertToken(TokenType.OPEN_CURLY_BRACKET, "{");
   }
 
   void test_open_paren() {
     _assertToken(TokenType.OPEN_PAREN, "(");
   }
 
   void test_open_square_bracket() {
     _assertToken(TokenType.OPEN_SQUARE_BRACKET, "[");
   }
 
+  void test_openSquareBracket() {
+    _assertToken(TokenType.OPEN_SQUARE_BRACKET, "[");
+  }
+
   void test_percent() {
     _assertToken(TokenType.PERCENT, "%");
   }
 
   void test_percent_eq() {
     _assertToken(TokenType.PERCENT_EQ, "%=");
   }
 
   void test_period() {
     _assertToken(TokenType.PERIOD, ".");
   }
 
+  void test_period_period() {
+    _assertToken(TokenType.PERIOD_PERIOD, "..");
+  }
+
+  void test_period_period_period() {
+    _assertToken(TokenType.PERIOD_PERIOD_PERIOD, "...");
+  }
+
   void test_periodAfterNumberNotIncluded_identifier() {
     _assertTokens("42.isEven()", [
       new StringToken(TokenType.INT, "42", 0),
       new Token(TokenType.PERIOD, 2),
       new StringToken(TokenType.IDENTIFIER, "isEven", 3),
       new Token(TokenType.OPEN_PAREN, 9),
       new Token(TokenType.CLOSE_PAREN, 10)
     ]);
   }
 
   void test_periodAfterNumberNotIncluded_period() {
     _assertTokens("42..isEven()", [
       new StringToken(TokenType.INT, "42", 0),
       new Token(TokenType.PERIOD_PERIOD, 2),
       new StringToken(TokenType.IDENTIFIER, "isEven", 4),
       new Token(TokenType.OPEN_PAREN, 10),
       new Token(TokenType.CLOSE_PAREN, 11)
     ]);
   }
 
-  void test_period_period() {
-    _assertToken(TokenType.PERIOD_PERIOD, "..");
-  }
-
-  void test_period_period_period() {
-    _assertToken(TokenType.PERIOD_PERIOD_PERIOD, "...");
-  }
-
   void test_plus() {
     _assertToken(TokenType.PLUS, "+");
   }
 
   void test_plus_eq() {
     _assertToken(TokenType.PLUS_EQ, "+=");
   }
 
   void test_plus_plus() {
     _assertToken(TokenType.PLUS_PLUS, "++");
   }
 
   void test_question() {
     _assertToken(TokenType.QUESTION, "?");
   }
 
   void test_scriptTag_withArgs() {
     _assertToken(TokenType.SCRIPT_TAG, "#!/bin/dart -debug");
   }
 
+  void test_scriptTag_withoutSpace() {
+    _assertToken(TokenType.SCRIPT_TAG, "#!/bin/dart");
+  }
+
   void test_scriptTag_withSpace() {
     _assertToken(TokenType.SCRIPT_TAG, "#! /bin/dart");
   }
 
-  void test_scriptTag_withoutSpace() {
-    _assertToken(TokenType.SCRIPT_TAG, "#!/bin/dart");
-  }
-
   void test_semicolon() {
     _assertToken(TokenType.SEMICOLON, ";");
   }
 
   void test_setSourceStart() {
     int offsetDelta = 42;
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner =
         new Scanner(null, new SubSequenceReader("a", offsetDelta), listener);
     scanner.setSourceStart(3, 9);
@@ skipping 97 matching lines @@
   void test_string_raw_multi_double() {
     _assertToken(TokenType.STRING, "r\"\"\"line1\nline2\"\"\"");
   }
 
   void test_string_raw_multi_single() {
     _assertToken(TokenType.STRING, "r'''string'''");
   }
 
   void test_string_raw_multi_unterminated() {
     String source = "r'''string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-        9, source, [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 9,
+        source, [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_raw_simple_double() {
     _assertToken(TokenType.STRING, "r\"string\"");
   }
 
   void test_string_raw_simple_single() {
     _assertToken(TokenType.STRING, "r'string'");
   }
 
   void test_string_raw_simple_unterminated_eof() {
     String source = "r'string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-        7, source, [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7,
+        source, [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_raw_simple_unterminated_eol() {
     String source = "r'string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-        8, "$source\n", [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 8,
+        "$source\n", [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_simple_double() {
     _assertToken(TokenType.STRING, "\"string\"");
   }
 
   void test_string_simple_escapedDollar() {
     _assertToken(TokenType.STRING, "'a\\\$b'");
   }
 
@@ skipping 75 matching lines @@
       new StringToken(TokenType.STRING, "1'", 2)
     ]);
   }
 
   void test_string_simple_single() {
     _assertToken(TokenType.STRING, "'string'");
   }
 
   void test_string_simple_unterminated_eof() {
     String source = "'string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-        6, source, [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 6,
+        source, [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_simple_unterminated_eol() {
     String source = "'string";
-    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL,
-        7, "$source\r", [new StringToken(TokenType.STRING, source, 0)]);
+    _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 7,
+        "$source\r", [new StringToken(TokenType.STRING, source, 0)]);
   }
 
   void test_string_simple_unterminated_interpolation_block() {
     _assertErrorAndTokens(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, 6,
         "'\${name", [
       new StringToken(TokenType.STRING, "'", 0),
       new StringToken(TokenType.STRING_INTERPOLATION_EXPRESSION, "\${", 1),
       new StringToken(TokenType.IDENTIFIER, "name", 3),
       new StringToken(TokenType.STRING, "", 7)
     ]);
@@ skipping 59 matching lines @@
    *
    * [expectedError] the error that should be produced
    * [expectedOffset] the string offset that should be associated with the error
    * [source] the source to be scanned to produce the error
    */
   void _assertError(
       ScannerErrorCode expectedError, int expectedOffset, String source) {
     GatheringErrorListener listener = new GatheringErrorListener();
     _scanWithListener(source, listener);
     listener.assertErrors([
-      new AnalysisError.con2(null, expectedOffset, 1, expectedError, [
-        source.codeUnitAt(expectedOffset)
-      ])
+      new AnalysisError.con2(null, expectedOffset, 1, expectedError,
+          [source.codeUnitAt(expectedOffset)])
     ]);
   }
 
   /**
    * Assert that scanning the given [source] produces an error with the given
    * code, and also produces the given tokens.
    *
    * [expectedError] the error that should be produced
    * [expectedOffset] the string offset that should be associated with the error
    * [source] the source to be scanned to produce the error
    * [expectedTokens] the tokens that are expected to be in the source
    */
   void _assertErrorAndTokens(ScannerErrorCode expectedError, int expectedOffset,
       String source, List<Token> expectedTokens) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Token token = _scanWithListener(source, listener);
     listener.assertErrors([
-      new AnalysisError.con2(null, expectedOffset, 1, expectedError, [
-        source.codeUnitAt(expectedOffset)
-      ])
+      new AnalysisError.con2(null, expectedOffset, 1, expectedError,
+          [source.codeUnitAt(expectedOffset)])
     ]);
     _checkTokens(token, expectedTokens);
   }
 
   /**
    * Assert that when scanned the given [source] contains a single keyword token
    * with the same lexeme as the original source.
    */
   void _assertKeywordToken(String source) {
     Token token = _scan(source);
@@ skipping 17 matching lines @@
     expect(token.next.type, TokenType.EOF);
   }
 
   void _assertLineInfo(
       String source, List<ScannerTest_ExpectedLocation> expectedLocations) {
     GatheringErrorListener listener = new GatheringErrorListener();
     _scanWithListener(source, listener);
     listener.assertNoErrors();
     LineInfo info = listener.getLineInfo(new TestSource());
     expect(info, isNotNull);
-    for (ScannerTest_ExpectedLocation expectedLocation in expectedLocations) {
+    int count = expectedLocations.length;
+    for (int i = 0; i < count; i++) {
+      ScannerTest_ExpectedLocation expectedLocation = expectedLocations[i];
       LineInfo_Location location = info.getLocation(expectedLocation._offset);
-      expect(location.lineNumber, expectedLocation._lineNumber);
-      expect(location.columnNumber, expectedLocation._columnNumber);
+      expect(location.lineNumber, expectedLocation._lineNumber,
+          reason: 'Line number in location $i');
+      expect(location.columnNumber, expectedLocation._columnNumber,
+          reason: 'Column number in location $i');
     }
   }
 
   /**
    * Assert that the token scanned from the given [source] has the
    * [expectedType].
    */
   Token _assertToken(TokenType expectedType, String source) {
     Token originalToken = _scan(source);
     expect(originalToken, isNotNull);
@@ skipping 223 matching lines @@
     expect(TokenType.LT_LT.isUserDefinableOperator, isTrue);
     expect(TokenType.MINUS.isUserDefinableOperator, isTrue);
     expect(TokenType.PERCENT.isUserDefinableOperator, isTrue);
     expect(TokenType.PLUS.isUserDefinableOperator, isTrue);
     expect(TokenType.SLASH.isUserDefinableOperator, isTrue);
     expect(TokenType.STAR.isUserDefinableOperator, isTrue);
     expect(TokenType.TILDE.isUserDefinableOperator, isTrue);
     expect(TokenType.TILDE_SLASH.isUserDefinableOperator, isTrue);
   }
 }