Add preliminary packages file support to dependency_grapher.

pkg/front_end/lib/dependency_grapher.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 '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/file_system.dart';
 import 'package:front_end/src/async_dependency_walker.dart';
 import 'package:front_end/src/base/uri_resolver.dart';
 import 'package:front_end/src/scanner/scanner.dart';
+import 'package:package_config/packages_file.dart' as package_config;
 
 import 'compiler_options.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.
 Future<Graph> graphForProgram(
     List<Uri> sources, CompilerOptions options) async {
-  var packages = <String, Uri>{}; // TODO(paulberry): support packages
+  Map<String, Uri> packages;
+  if (options.packagesFilePath == null) {
+    throw new UnimplementedError(); // TODO(paulberry): search for .packages

[Siggi Cherem (dart-lang), 2016/12/16 16:30:38]

mmm... I recognize the value of having an abstraction for the file system in
front-end, but I hope we can avoid duplicating the discovery algorithms for
this.

Some ideas:
 - move package-config to frontend (I personally like keeping it separate
though)
 - limit when we support some features, for example, package-discovery is only
supported when using the IO file system

[Paul Berry, 2016/12/16 17:59:07]

Acknowledged.

+  } else if (options.packagesFilePath.isEmpty) {
+    packages = {};
+  } else {
+    var contents = await options.fileSystem
+        .entityForPath(options.packagesFilePath)
+        .readAsBytes();
+    var baseLocation =
+        options.fileSystem.context.toUri(options.packagesFilePath);
+    packages = package_config.parse(contents, baseLocation);
+  }
   var sdkLibraries = <String, Uri>{}; // TODO(paulberry): support SDK libraries
   var uriResolver =
       new UriResolver(packages, sdkLibraries, options.fileSystem.context);
   var walker = new _Walker(options.fileSystem, uriResolver);
   var startingPoint = new _StartingPoint(walker, sources);
   await walker.walk(startingPoint);
   return walker.graph;
 }
 
 /// A representation of the dependency graph of a program.
@@ skipping 93 matching lines @@
   final LibraryNode library;
 
   _WalkerNode(this.walker, Uri uri)
       : uri = uri,
         library = new LibraryNode._(uri);
 
   @override
   Future<List<_WalkerNode>> computeDependencies() async {
     var dependencies = <_WalkerNode>[];
     // TODO(paulberry): add error recovery if the file can't be read.
-    var contents = await walker.fileSystem
-        .entityForPath(walker.uriResolver.resolve(uri))
-        .readAsString();
+    var path = walker.uriResolver.resolve(uri);
+    if (path == 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.fileSystem.entityForPath(path).readAsString();
     var scanner = new _Scanner(contents);
     var token = scanner.tokenize();
     // TODO(paulberry): report errors.
     var parser = new Parser(null, AnalysisErrorListener.NULL_LISTENER);
     var unit = parser.parseDirectives(token);
     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 {
           _WalkerNode dependencyNode = walker.nodeForUri(referencedUri);
           dependencies.add(dependencyNode);
           library.dependencies.add(dependencyNode.library);
         }
       }
     }
     return dependencies;
   }
 }