Remove use of package:analyzer in dependency_grapher

pkg/front_end/lib/src/dependency_grapher_impl.dart

 // Copyright (c) 2017, 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 'dart:async';
 
-import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/error/listener.dart';
-import 'package:analyzer/src/dart/scanner/reader.dart';
-import 'package:analyzer/src/generated/parser.dart';
 import 'package:front_end/dependency_grapher.dart';
 import 'package:front_end/src/async_dependency_walker.dart';
 import 'package:front_end/src/base/processed_options.dart';
 import 'package:front_end/src/base/uri_resolver.dart';
-import 'package:front_end/src/scanner/scanner.dart';
+import 'package:front_end/src/fasta/parser.dart';
+import 'package:front_end/src/fasta/scanner.dart';
+import 'package:front_end/src/fasta/source/directive_listener.dart';
 
 /// Generates a representation of the dependency graph of a program.
 ///
 /// Given the Uri of one or more files, this function follows `import`,
 /// `export`, and `part` declarations to discover a graph of all files involved
 /// in the program.
 ///
 /// If a [fileReader] is supplied, it is used to read file contents; otherwise
 /// they are read directly from `options.fileSystem`.
 ///
 /// This is intended for internal use by the front end.  Clients should use
 /// package:front_end/dependency_grapher.dart.
 Future<Graph> graphForProgram(List<Uri> sources, ProcessedOptions options,
     {FileReader fileReader}) async {
   var uriResolver = await options.getUriResolver();
   fileReader ??= (originalUri, resolvedUri) =>
       options.fileSystem.entityForUri(resolvedUri).readAsString();
   var walker = new _Walker(fileReader, uriResolver, options.compileSdk);
   var startingPoint = new _StartingPoint(walker, sources);
   await walker.walk(startingPoint);
   return walker.graph;
 }
 
 /// Type of the callback function used by [graphForProgram] to read file
 /// contents.
 typedef Future<String> FileReader(Uri originalUri, Uri resolvedUri);
 
-class _Scanner extends Scanner {
-  _Scanner(String contents) : super.create(new CharSequenceReader(contents)) {
-    preserveComments = false;
-  }
-
-  @override
-  void reportError(errorCode, int offset, List<Object> arguments) {
-    // TODO(paulberry): report errors.
-  }
-}
-
 class _StartingPoint extends _WalkerNode {
   final List<Uri> sources;
 
   _StartingPoint(_Walker walker, this.sources) : super(walker, null);
 
   @override
   Future<List<_WalkerNode>> computeDependencies() async =>
       sources.map(walker.nodeForUri).toList();
 }
 
@@ skipping 43 matching lines @@
   Future<List<_WalkerNode>> computeDependencies() async {
     var dependencies = <_WalkerNode>[];
     // TODO(paulberry): add error recovery if the file can't be read.
     var resolvedUri = walker.uriResolver.resolve(uri);
     if (resolvedUri == null) {
       // TODO(paulberry): If an error reporter was provided, report the error
       // in the proper way and continue.
       throw new StateError('Invalid URI: $uri');
     }
     var contents = await walker.fileReader(uri, resolvedUri);
-    var scanner = new _Scanner(contents);
-    var token = scanner.tokenize();
+    var scannerResults = scanString(contents);
     // TODO(paulberry): report errors.
-    var parser = new Parser(null, AnalysisErrorListener.NULL_LISTENER);
-    var unit = parser.parseDirectives(token);
+    var listener = new DirectiveListener();
+    new TopLevelParser(listener).parseUnit(scannerResults.tokens);
     bool coreUriFound = false;
     void handleDependency(Uri referencedUri) {
       _WalkerNode dependencyNode = walker.nodeForUri(referencedUri);
       library.dependencies.add(dependencyNode.library);
       if (referencedUri.scheme != 'dart' || walker.compileSdk) {
         dependencies.add(dependencyNode);
       }
       if (referencedUri == dartCoreUri) {
         coreUriFound = true;
       }
     }
 
-    for (var directive in unit.directives) {
-      if (directive is UriBasedDirective) {
-        // TODO(paulberry): when we support SDK libraries, we'll need more
-        // complex logic here to find SDK parts correctly.
-        var referencedUri = uri.resolve(directive.uri.stringValue);
-        if (directive is PartDirective) {
-          library.parts.add(referencedUri);
-        } else {
-          handleDependency(referencedUri);
-        }
-      }
+    for (var part in listener.parts) {
+      // TODO(paulberry): when we support SDK libraries, we'll need more
+      // complex logic here to find SDK parts correctly.
+      library.parts.add(uri.resolve(part));
     }
+
+    for (var dep in listener.imports) {
+      handleDependency(uri.resolve(dep));
+    }
+
+    for (var dep in listener.exports) {
+      handleDependency(uri.resolve(dep));
+    }
+
     if (!coreUriFound) {
       handleDependency(dartCoreUri);
     }
     return dependencies;
   }
 }