Improve parallelism when loading transformer plugins.

sdk/lib/_internal/pub/lib/src/barback.dart

 // Copyright (c) 2013, 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 pub.barback;
 
 import 'dart:async';
 
 import 'package:barback/barback.dart';
-import 'package:path/path.dart' as path;
+import 'package:collection/collection.dart';
+import 'package:path/path.dart' as p;
 
+import 'io.dart';
 import 'utils.dart';
 import 'version.dart';
 
 /// The currently supported versions of the Barback package that this version of
 /// pub works with.
 ///
 /// Pub implicitly constrains barback to these versions.
 ///
 /// Barback is in a unique position. Pub imports it, so a copy of Barback is
 /// physically included in the SDK. Packages also depend on Barback (from
@@ skipping 144 matching lines @@
         includes, excludes);
   }
 
   TransformerId._(this.package, this.path, this.configuration,
       this.includes, this.excludes) {
     if (!package.startsWith('\$')) return;
     if (_BUILT_IN_TRANSFORMERS.contains(package)) return;
     throw new FormatException('Unsupported built-in transformer $package.');
   }
 
-  // TODO(nweiz): support deep equality on [configuration] as well.
   bool operator==(other) => other is TransformerId &&
       other.package == package &&
       other.path == path &&
-      other.configuration == configuration;
+      const DeepCollectionEquality().equals(other.configuration, configuration);
 
-  int get hashCode => package.hashCode ^ path.hashCode ^ configuration.hashCode;
+  int get hashCode => package.hashCode ^ path.hashCode ^
+      const DeepCollectionEquality().hash(configuration);
 
   String toString() => path == null ? package : '$package/$path';
 
   /// Returns the asset id for the library identified by this transformer id.
   ///
   /// If `path` is null, this will determine which library to load.
   Future<AssetId> getAssetId(Barback barback) {
     if (path != null) {
       return new Future.value(new AssetId(package, 'lib/$path.dart'));
     }
 
     var transformerAsset = new AssetId(package, 'lib/transformer.dart');
     return barback.getAssetById(transformerAsset).then((_) => transformerAsset)
         .catchError((e) => new AssetId(package, 'lib/$package.dart'),
             test: (e) => e is AssetNotFoundException);
   }
 
+  /// Returns the path to the library identified by this transformer within
+  /// [packageDir], which should be the directory of [package].
+  ///
+  /// If `path` is null, this will determine which library to load. Unlike
+  /// [getAssetId], this doesn't take generated assets into account; it's used
+  /// to determine transformers' dependencies, which requires looking at files
+  /// on disk.
+  String getFullPath(String packageDir) {
+    if (path != null) return p.join(packageDir, 'lib', p.fromUri('$path.dart'));
+
+    var transformerPath = p.join(packageDir, 'lib', 'transformer.dart');
+    if (fileExists(transformerPath)) return transformerPath;
+    return p.join(packageDir, 'lib', '$package.dart');
+  }
+
   /// Returns whether the include/exclude rules allow the transformer to run on
   /// [pathWithinPackage].
   ///
-  /// [pathWithinPackage] must be a path relative to the containing package's
-  /// root directory.
+  /// [pathWithinPackage] must be a URL-style path relative to the containing
+  /// package's root directory.
   bool canTransform(String pathWithinPackage) {
     // TODO(rnystrom): Support globs in addition to paths. See #17093.
     if (excludes != null) {
       // If there are any excludes, it must not match any of them.
       if (excludes.contains(pathWithinPackage)) return false;
     }
 
     // If there are any includes, it must match one of them.
     return includes == null || includes.contains(pathWithinPackage);
   }
 }
 
 /// Converts [id] to a "package:" URI.
 ///
 /// This will throw an [ArgumentError] if [id] doesn't represent a library in
 /// `lib/`.
 Uri idToPackageUri(AssetId id) {
   if (!id.path.startsWith('lib/')) {
     throw new ArgumentError("Asset id $id doesn't identify a library.");
   }
 
   return new Uri(scheme: 'package',
-      path: path.url.join(id.package, id.path.replaceFirst('lib/', '')));
+      path: p.url.join(id.package, id.path.replaceFirst('lib/', '')));
 }
 
 /// Converts [uri] into an [AssetId] if its path is within "packages".
 ///
 /// If the URL contains a special directory, but lacks a following package name,
 /// throws a [FormatException].
 ///
 /// If the URI doesn't contain one of those special directories, returns null.
 AssetId packagesUrlToId(Uri url) {
-  var parts = path.url.split(url.path);
+  var parts = p.url.split(url.path);
 
   // Strip the leading "/" from the URL.
   if (parts.isNotEmpty && parts.first == "/") parts = parts.skip(1).toList();
 
   if (parts.isEmpty) return null;
 
   // Check for "packages" in the URL.
   // TODO(rnystrom): If we rewrite "package:" imports to relative imports that
   // point to a canonical "packages" directory, we can limit "packages" to the
   // root of the URL as well. See: #16649.
   var index = parts.indexOf("packages");
   if (index == -1) return null;
 
   // There should be a package name after "packages".
   if (parts.length <= index + 1) {
     throw new FormatException(
         'Invalid URL path "${url.path}". Expected package name '
         'after "packages".');
   }
 
   var package = parts[index + 1];
-  var assetPath = path.url.join("lib", path.url.joinAll(parts.skip(index + 2)));
+  var assetPath = p.url.join("lib", p.url.joinAll(parts.skip(index + 2)));
   return new AssetId(package, assetPath);
 }