Stop testing scanner error lengths.

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 1082 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,
       [List<Object> arguments]) {
     ErrorListener listener = new ErrorListener();
     scanWithListener(source, listener);
     listener.assertErrors(
-        [new TestError(expectedOffset, 1, expectedError, arguments)]);
+        [new TestError(expectedOffset, expectedError, arguments)]);
   }
 
   /**
    * 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) {
     ErrorListener listener = new ErrorListener();
     Token token = scanWithListener(source, listener);
-    listener
-        .assertErrors([new TestError(expectedOffset, 1, expectedError, null)]);
+    listener.assertErrors([new TestError(expectedOffset, expectedError, null)]);
     _checkTokens(token, expectedTokens);
   }
 
   /**
    * Assert that when scanned the given [source] contains a single identifier
    * token with the same lexeme as the original source.
    */
   void _assertIdentifierToken(String source) {
     void check(String s, int expectedOffset) {
       Token token = _scan(s);
@@ skipping 125 matching lines @@
     Token token = scanWithListener(source, listener,
         genericMethodComments: genericMethodComments,
         lazyAssignmentOperators: lazyAssignmentOperators);
     listener.assertNoErrors();
     return token;
   }
 }
 
 class TestError {
   final int offset;
-  final int length;
   final ErrorCode errorCode;
   final List<Object> arguments;
 
-  TestError(this.offset, this.length, this.errorCode, this.arguments);
+  TestError(this.offset, this.errorCode, this.arguments);
 
   @override
   get hashCode {
-    var h = new JenkinsSmiHash()..add(offset)..add(length)..add(errorCode);
+    var h = new JenkinsSmiHash()..add(offset)..add(errorCode);
     if (arguments != null) {
       for (Object argument in arguments) {
         h.add(argument);
       }
     }
     return h.hashCode;
   }
 
   @override
   operator ==(Object other) {
     if (other is TestError &&
         offset == other.offset &&
-        length == other.length &&
         errorCode == other.errorCode) {
       if (arguments == null) return other.arguments == null;
       if (other.arguments == null) return false;
       if (arguments.length != other.arguments.length) return false;
       for (int i = 0; i < arguments.length; i++) {
         if (arguments[i] != other.arguments[i]) return false;
       }
       return true;
     }
     return false;
   }
 
   @override
   toString() {
-    var end = offset + length;
     var argString = arguments == null ? '' : '(${arguments.join(', ')})';
-    return 'Error($offset..$end, $errorCode$argString)';
+    return 'Error($offset, $errorCode$argString)';
   }
 }
 
 @reflectiveTest
 class TokenTypeTest {
   void test_isOperator() {
     expect(TokenType.AMPERSAND.isOperator, isTrue);
     expect(TokenType.AMPERSAND_AMPERSAND.isOperator, isTrue);
     expect(TokenType.AMPERSAND_EQ.isOperator, isTrue);
     expect(TokenType.BANG.isOperator, isTrue);
@@ skipping 60 matching lines @@
 
 class _TestScanner extends Scanner {
   final ErrorListener listener;
 
   _TestScanner(CharacterReader reader, [this.listener]) : super(reader);
 
   @override
   void reportError(
       ScannerErrorCode errorCode, int offset, List<Object> arguments) {
     if (listener != null) {
-      listener.errors.add(new TestError(offset, 1, errorCode, arguments));
+      listener.errors.add(new TestError(offset, errorCode, arguments));
     }
   }
 }