support resolving .packages in FE

pkg/front_end/lib/src/base/processed_options.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:front_end/compilation_error.dart';
 import 'package:front_end/compiler_options.dart';
 import 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/fasta/fasta_codes.dart';
 import 'package:front_end/src/fasta/ticker.dart';
 import 'package:front_end/src/fasta/uri_translator.dart';
 import 'package:front_end/src/fasta/uri_translator_impl.dart';
 import 'package:front_end/src/fasta/problems.dart' show unimplemented;
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:front_end/src/multi_root_file_system.dart';
 import 'package:kernel/kernel.dart'
     show Program, loadProgramFromBytes, CanonicalName;
 import 'package:kernel/target/targets.dart';
 import 'package:kernel/target/vm_fasta.dart';
+import 'package:package_config/packages.dart' show Packages;
+import 'package:package_config/src/packages_impl.dart'
+    show NonFilePackagesDirectoryPackages, MapPackages;
 import 'package:package_config/packages_file.dart' as package_config;
 import 'package:source_span/source_span.dart' show SourceSpan, SourceLocation;
 
 /// All options needed for the front end implementation.
 ///
 /// This includes: all of [CompilerOptions] in a form useful to the
 /// implementation, default values for options that were not provided,
 /// and information derived from how the compiler was invoked (like the
 /// entry-points given to the compiler and whether a modular or whole-program
 /// API was used).
 ///
 /// The intent is that the front end should immediately wrap any incoming
 /// [CompilerOptions] object in this class before doing further processing, and
 /// should thereafter access all options via the wrapper.  This ensures that
 /// options are interpreted in a consistent way and that data derived from
 /// options is not unnecessarily recomputed.
 class ProcessedOptions {
   /// The raw [CompilerOptions] which this class wraps.
   final CompilerOptions _raw;
 
   /// The package map derived from the options, or `null` if the package map has
   /// not been computed yet.
-  Map<String, Uri> _packages;
+  Packages _packages;
 
   /// The object that knows how to resolve "package:" and "dart:" URIs,
   /// or `null` if it has not been computed yet.
   UriTranslatorImpl _uriTranslator;
 
   /// The SDK summary, or `null` if it has not been read yet.
   ///
   /// A summary, also referred to as "outline" internally, is a [Program] where
   /// all method bodies are left out. In essence, it contains just API
   /// signatures and constants. When strong-mode is enabled, the summary already
@@ skipping 66 matching lines @@
   void reportMessage(LocatedMessage message) {
     _raw.onError(new _CompilationMessage(message));
   }
 
   void reportMessageWithoutLocation(Message message) =>
       reportMessage(message.withLocation(null, -1));
 
   /// Runs various validations checks on the input options. For instance,
   /// if an option is a path to a file, it checks that the file exists.
   Future<bool> validateOptions() async {
+    if (inputs.isEmpty) {
+      reportMessageWithoutLocation(messageMissingInputs);

[ahe, 2017/07/14 13:44:57]

Remove the "s" from Inputs.

[Siggi Cherem (dart-lang), 2017/07/14 19:54:06]

Done. Also updated the other messages to say "NotFound" to distingish better
when they are missing because they not provided or not found.

+      return false;
+    }
+
     for (var source in inputs) {
-      if (source.scheme == 'file' &&
+      // Note: we don't translate Uris at this point because some of the
+      // validation further below must be done before we even construct an
+      // UriTranslator

[ahe, 2017/07/14 13:44:57]

Can we make this a TODO and check the inputs later?

[Siggi Cherem (dart-lang), 2017/07/14 19:54:06]

Sure, but it will require some subtle ordering of checks, because if .packages
is not given explicitly, we need to know the inptus to infer a .packages for
uritranslator.

+      if (source.scheme != 'dart' &&
+          source.scheme != 'packages' &&
           !await fileSystem.entityForUri(source).exists()) {
         reportMessageWithoutLocation(
             templateMissingInputFile.withArguments('$source'));
         return false;
       }
     }
 
     if (_raw.sdkRoot != null &&
         !await fileSystem.entityForUri(sdkRoot).exists()) {
       reportMessageWithoutLocation(
@@ skipping 103 matching lines @@
 
   Future<Map<String, Uri>> _parseDartLibraries() async {
     Uri librariesJson = _raw.sdkRoot?.resolve("lib/libraries.json");
     return await computeDartLibraries(fileSystem, librariesJson);
   }
 
   /// Get the package map which maps package names to URIs.
   ///
   /// This is an asynchronous getter since file system operations may be
   /// required to locate/read the packages file.
-  Future<Map<String, Uri>> _getPackages() async {
+  Future<Packages> _getPackages() async {
     if (_packages == null) {
       if (_raw.packagesFileUri == null) {
-        // TODO(sigmund,paulberry): implement
-        return unimplemented('search for .packages');
-      } else if (_raw.packagesFileUri.path.isEmpty) {
-        _packages = {};
+        if (inputs.length > 1) {
+          reportMessageWithoutLocation(
+              templateInternalProblemUnsupported.withArguments(
+                  "Cannot infer a .packages file when compiling multiple inputs."));

[ahe, 2017/07/14 13:44:57]

This isn't an internal error, this is a problem with how the API is being used,
and an error that we may report to an end user.

Also, I think there's a tip for this message: "Try adding --packages option."

There's also a possible todo here: we can make a loop and call _findPackages
multiple times and only report an error if we get different answers.

[Siggi Cherem (dart-lang), 2017/07/14 19:54:06]

Done.

Note we have to be careful about using flags (like --packages) as tips because
most users of the FE will consume it indirectly from another tool and not
directly from the command line. We have to make sure all tools agree on the
flags before we use them in the tips.

I think `--packages` is a safe one though.
 
done.

+          _packages = Packages.noPackages;
+        } else {
+          _packages = await _findPackages(inputs.first);
+        }
       } else {
-        var contents =
-            await fileSystem.entityForUri(_raw.packagesFileUri).readAsBytes();
-        _packages = package_config.parse(contents, _raw.packagesFileUri);
+        _packages = await createPackagesFromFile(_raw.packagesFileUri);
       }
     }
     return _packages;
   }
 
+  /// Create a [Packages] given the Uri to a `.packages` file.
+  Future<Packages> createPackagesFromFile(Uri file) async {
+    try {
+      List<int> contents = await fileSystem.entityForUri(file).readAsBytes();
+      Map<String, Uri> map = package_config.parse(contents, file);
+      return new MapPackages(map);
+    } catch (e) {
+      reportMessageWithoutLocation(
+          templateInvalidPackagesFile.withArguments(file, "$e"));
+      return Packages.noPackages;
+    }
+  }
+
+  /// Finds a package resolution strategy using a [FileSystem].
+  ///
+  /// The [scriptUri] points to a Dart script with a valid scheme accepted by
+  /// the [FileSystem].
+  ///
+  /// This function first tries to locate a `.packages` file in the `scriptUri`
+  /// directory. If that is not found, it instead checks for the presence of a
+  /// `packages/` directory in the same place.  If that also fails, it starts
+  /// checking parent directories for a `.packages` file, and stops if it finds
+  /// it.  Otherwise it gives up and returns [Packages.noPackages].
+  ///
+  /// Note: this is a fork from `package:package_config/discovery.dart` to adapt
+  /// it to use [FileSystem]. The logic here is a mix of the logic in the
+  /// `findPackagesFromFile` and `findPackagesFromNonFile`:
+  ///
+  ///    * Like `findPackagesFromFile` resolution searches for parent
+  ///    directories
+  ///
+  ///    * Like `findPackagesFromNonFile` if we resolve packages as the
+  ///    `packages/` directory, we can't provide a list of packages that are
+  ///    visible.
+  Future<Packages> _findPackages(Uri scriptUri) async {
+    var dir = scriptUri.resolve('.');
+    if (!dir.isAbsolute) {
+      reportMessageWithoutLocation(templateInternalProblemUnsupported
+          .withArguments("Expected input Uri to be absolute: $scriptUri."));
+      return null;
+    }
+    if (!await fileSystem.entityForUri(dir).exists()) {
+      reportMessageWithoutLocation(templateInternalProblemUnsupported
+          .withArguments("Input directory does not exist: $dir."));
+      // TODO: report "Directory does not exist.";
+      return null;
+    }
+
+    Future<Uri> checkInDir(Uri dir) async {
+      Uri candidate = dir.resolve('.packages');
+      if (await fileSystem.entityForUri(candidate).exists()) return candidate;
+      return null;
+    }
+
+    // Check for $cwd/.packages
+    var candidate = await checkInDir(dir);
+    if (candidate != null) return createPackagesFromFile(candidate);
+
+    // Check for $cwd/packages/
+    var packagesDir = dir.resolve("packages/");
+    if (await fileSystem.entityForUri(packagesDir).exists()) {
+      return new NonFilePackagesDirectoryPackages(packagesDir);
+    }
+
+    // Check for cwd(/..)+/.packages
+    var parentDir = dir.resolve('..');
+    while (parentDir.path != dir.path) {
+      candidate = await checkInDir(parentDir);
+      if (candidate != null) break;
+      dir = parentDir;
+      parentDir = dir.resolve('..');
+    }
+
+    if (candidate != null) return createPackagesFromFile(candidate);
+    return Packages.noPackages;
+  }
+
   /// Get the location of the SDK.
   Uri _normalizeSdkRoot() {
     // If an SDK summary location was provided, the SDK itself should not be
     // needed.
     assert(_raw.sdkSummary == null);
     if (_raw.sdkRoot == null) {
       // TODO(paulberry): implement the algorithm for finding the SDK
       // automagically.
       return unimplemented('infer the default sdk location');
     }
@@ skipping 96 matching lines @@
 /// Wraps an error message as a [CompilationError] API.
 class _StringMessage implements CompilationError {
   final String message;
   String get tip => null;
   SourceSpan get span => null;
 
   _StringMessage(this.message);
 
   String toString() => message;
 }