Use packages dart_parser, dart_scanner, and compiler_util.

pkg/compiler/lib/src/resolution/members.dart

 // Copyright (c) 2012, 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 dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show Selectors;
 import '../common/resolution.dart' show Resolution;
 import '../compile_time_constants.dart';
 import '../constants/constructors.dart'
     show RedirectingFactoryConstantConstructor;
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../core_types.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart'
     show
         ConstructorElementX,
         ErroneousElementX,
         FunctionElementX,
         JumpTargetX,
         LocalFunctionElementX,
         LocalParameterElementX,
         ParameterElementX,
         VariableElementX,
         VariableList;
 import '../options.dart';
-import '../tokens/token.dart' show isUserDefinableOperator;
+import 'package:dart_scanner/dart_scanner.dart' show isUserDefinableOperator;
 import '../tree/tree.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/feature.dart' show Feature;
 import '../universe/selector.dart' show Selector;
 import '../universe/use.dart' show DynamicUse, StaticUse, TypeUse;
 import '../util/util.dart' show Link;
 import 'access_semantics.dart';
 import 'class_members.dart' show MembersCreator;
 import 'constructors.dart'
     show ConstructorResolver, ConstructorResult, ConstructorResultKind;
@@ skipping 3550 matching lines @@
             {'modifier': currentAsyncMarker});
       }
     }
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitYield(Yield node) {
     if (!resolution.target.supportsAsyncAwait) {
       reporter.reportErrorMessage(
-          node.yieldToken, MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
+          reporter.spanFromToken(node.yieldToken),
+          MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
     } else {
       if (!currentAsyncMarker.isYielding) {
         reporter.reportErrorMessage(node, MessageKind.INVALID_YIELD);
       }
       if (currentAsyncMarker.isAsync) {
         commonElements.streamClass.ensureResolved(resolution);
       } else {
         commonElements.iterableClass.ensureResolved(resolution);
       }
     }
@@ skipping 118 matching lines @@
 
   ResolutionResult visitThrow(Throw node) {
     registry.registerFeature(Feature.THROW_EXPRESSION);
     visit(node.expression);
     return const NoneResult();
   }
 
   ResolutionResult visitAwait(Await node) {
     if (!resolution.target.supportsAsyncAwait) {
       reporter.reportErrorMessage(
-          node.awaitToken, MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
+          reporter.spanFromToken(node.awaitToken),
+          MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
     } else {
       if (!currentAsyncMarker.isAsync) {
         reporter.reportErrorMessage(node, MessageKind.INVALID_AWAIT);
       }
       commonElements.futureClass.ensureResolved(resolution);
     }
     visit(node.expression);
     return const NoneResult();
   }
 
@@ skipping 240 matching lines @@
           registry.registerNewStructure(node, structure.resolve(node));
         };
       }
 
       analyzeConstantDeferred(node, onAnalyzed: onAnalyzed);
     } else {
       // Not constant.
       if (resolution.commonElements.isSymbolConstructor(constructor) &&
           !resolution.mirrorUsageAnalyzerTask
               .hasMirrorUsage(enclosingElement)) {
-        reporter.reportHintMessage(node.newToken, MessageKind.NON_CONST_BLOAT,
+        reporter.reportHintMessage(reporter.spanFromToken(node.newToken),
+            MessageKind.NON_CONST_BLOAT,
             {'name': commonElements.symbolClass.name});
       }
       registry.registerNewStructure(
           node,
           new NewInvokeStructure(
               new ConstructorAccessSemantics(kind, constructor, type),
               selector));
     }
 
     return resolutionResult;
@@ skipping 251 matching lines @@
       label.setContinueTarget();
       registry.useLabel(node, label);
     }
     registry.registerTargetOf(node, target);
     return const NoneResult();
   }
 
   ResolutionResult visitAsyncForIn(AsyncForIn node) {
     if (!resolution.target.supportsAsyncAwait) {
       reporter.reportErrorMessage(
-          node.awaitToken, MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
+          reporter.spanFromToken(node.awaitToken),
+          MessageKind.ASYNC_AWAIT_NOT_SUPPORTED);
     } else {
       if (!currentAsyncMarker.isAsync) {
         reporter.reportErrorMessage(
-            node.awaitToken, MessageKind.INVALID_AWAIT_FOR_IN);
+            reporter.spanFromToken(node.awaitToken),
+            MessageKind.INVALID_AWAIT_FOR_IN);
       }
       registry.registerFeature(Feature.ASYNC_FOR_IN);
       registry.registerDynamicUse(new DynamicUse(Selectors.current, null));
       registry.registerDynamicUse(new DynamicUse(Selectors.moveNext, null));
     }
     visit(node.expression);
 
     Scope blockScope = new BlockScope(scope);
     visitForInDeclaredIdentifierIn(node.declaredIdentifier, node, blockScope);
     visitLoopBodyIn(node, node.body, blockScope);
@@ skipping 379 matching lines @@
   }
 
   ResolutionResult visitTryStatement(TryStatement node) {
     // TODO(karlklose): also track the information about mutated variables,
     // catch, and finally-block.
     registry.registerTryStatement();
 
     visit(node.tryBlock);
     if (node.catchBlocks.isEmpty && node.finallyBlock == null) {
       reporter.reportErrorMessage(
-          node.getEndToken().next, MessageKind.NO_CATCH_NOR_FINALLY);
+          reporter.spanFromToken(node.getEndToken().next),
+          MessageKind.NO_CATCH_NOR_FINALLY);
     }
     visit(node.catchBlocks);
     visit(node.finallyBlock);
     return const NoneResult();
   }
 
   ResolutionResult visitCatchBlock(CatchBlock node) {
     registry.registerFeature(Feature.CATCH_STATEMENT);
     // Check that if catch part is present, then
     // it has one or two formal parameters.
@@ skipping 75 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(
     DiagnosticReporter reporter, Node node, Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }