Move scanner into pkg/front_end/lib/src/scanner.

pkg/analyzer/test/generated/parser_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 analyzer.test.generated.parser_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/error/error.dart';
@@ skipping 2919 matching lines @@
       expect(result, isNotNull);
     }
   }
 
   /**
    * Parse the given [source] as a compilation unit. Throw an exception if the
    * source could not be parsed, if the compilation errors in the source do not
    * match those that are expected, or if the result would have been `null`.
    */
   CompilationUnit parseCompilationUnitWithOptions(String source,
-      [List<ErrorCode> errorCodes = ErrorCode.EMPTY_LIST]) {
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
     CompilationUnit unit = parser.parseCompilationUnit2();
     expect(unit, isNotNull);
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
   }
 
   /**
    * Parse the given source as an expression.
    *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the expression that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
    *           not match those that are expected, or if the result would have been `null`
    */
   Expression parseExpression(String source,
-      [List<ErrorCode> errorCodes = ErrorCode.EMPTY_LIST]) {
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
     Expression expression = parser.parseExpression2();
     expectNotNullIfNoErrors(expression);
     listener.assertErrorsWithCodes(errorCodes);
     return expression;
   }
 
   @override
   void setUp() {
     super.setUp();
     parseFunctionBodies = true;
   }
 
   /**
    * Parse the given source as a compilation unit.
    *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the compilation unit that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
    *           not match those that are expected, or if the result would have been `null`
    */
   static CompilationUnit parseCompilationUnit(String source,
-      [List<ErrorCode> errorCodes = ErrorCode.EMPTY_LIST]) {
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner =
         new Scanner(null, new CharSequenceReader(source), listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     CompilationUnit unit = parser.parseCompilationUnit(token);
     expect(unit, isNotNull);
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
@@ skipping 14 matching lines @@
     return unit;
   }
 
   /**
    * Parse the given [source] as a statement. The [errorCodes] are the error
    * codes of the errors that are expected to be found. If
    * [enableLazyAssignmentOperators] is `true`, then lazy assignment operators
    * should be enabled.
    */
   static Statement parseStatement(String source,
-      [List<ErrorCode> errorCodes = ErrorCode.EMPTY_LIST,
+      [List<ErrorCode> errorCodes = const <ErrorCode>[],
       bool enableLazyAssignmentOperators]) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner =
         new Scanner(null, new CharSequenceReader(source), listener);
     scanner.scanLazyAssignmentOperators = enableLazyAssignmentOperators;
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     Statement statement = parser.parseStatement(token);
     expect(statement, isNotNull);
     listener.assertErrorsWithCodes(errorCodes);
     return statement;
   }
 
   /**
    * Parse the given source as a sequence of statements.
    *
    * @param source the source to be parsed
    * @param expectedCount the number of statements that are expected
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the statements that were parsed
    * @throws Exception if the source could not be parsed, if the number of statements does not match
    *           the expected count, if the compilation errors in the source do not match those that
    *           are expected, or if the result would have been `null`
    */
   static List<Statement> parseStatements(String source, int expectedCount,
-      [List<ErrorCode> errorCodes = ErrorCode.EMPTY_LIST]) {
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     GatheringErrorListener listener = new GatheringErrorListener();
     Scanner scanner =
         new Scanner(null, new CharSequenceReader(source), listener);
     listener.setLineInfo(new TestSource(), scanner.lineStarts);
     Token token = scanner.tokenize();
     Parser parser = new Parser(null, listener);
     List<Statement> statements = parser.parseStatements(token);
     expect(statements, hasLength(expectedCount));
     listener.assertErrorsWithCodes(errorCodes);
     return statements;
@@ skipping 10410 matching lines @@
   /**
    * Parse the given source as a compilation unit.
    *
    * @param source the source to be parsed
    * @param errorCodes the error codes of the errors that are expected to be found
    * @return the compilation unit that was parsed
    * @throws Exception if the source could not be parsed, if the compilation errors in the source do
    *           not match those that are expected, or if the result would have been `null`
    */
   CompilationUnit _parseDirectives(String source,
-      [List<ErrorCode> errorCodes = ErrorCode.EMPTY_LIST]) {
+      [List<ErrorCode> errorCodes = const <ErrorCode>[]]) {
     createParser(source);
     CompilationUnit unit = parser.parseDirectives2();
     expect(unit, isNotNull);
     expect(unit.declarations, hasLength(0));
     listener.assertErrorsWithCodes(errorCodes);
     return unit;
   }
 }