Revert "Use native async/await support in pub."

sdk/lib/_internal/pub_generated/lib/src/barback/dependency_computer.dart

 // Copyright (c) 2014, 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.dependency_computer;
 
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as p;
 
 import '../dart.dart';
@@ skipping 26 matching lines @@
   final _transformersNeededByPackages = new Map<String, Set<TransformerId>>();
 
   /// The set of all packages that neither use transformers themselves nor
   /// import packages that use transformers.
   ///
   /// This is precomputed before any package computers are loaded.
   final _untransformedPackages = new Set<String>();
 
   DependencyComputer(this._graph) {
     for (var package in ordered(_graph.packages.keys)) {
-      if (_graph.transitiveDependencies(package).every((dependency) =>
-            dependency.pubspec.transformers.isEmpty)) {
+      if (_graph.transitiveDependencies(
+          package).every((dependency) => dependency.pubspec.transformers.isEmpty)) {
         _untransformedPackages.add(package);
       }
     }
 
     ordered(_graph.packages.keys).forEach(_loadPackageComputer);
   }
 
   /// Returns a dependency graph for [transformers], or for all transformers if
   /// [transformers] is `null`.
   ///
   /// This graph is represented by a map whose keys are the vertices and whose
   /// values are sets representing edges from the given vertex. Each vertex is a
   /// [TransformerId]. If there's an edge from `T1` to `T2`, then `T2` must be
   /// loaded before `T1` can be loaded.
   ///
   /// The returned graph is transitively closed. That is, if there's an edge
   /// from `T1` to `T2` and an edge from `T2` to `T3`, there's also an edge from
   /// `T1` to `T2`.
-  Map<TransformerId, Set<TransformerId>> transformersNeededByTransformers(
-      [Iterable<TransformerId> transformers]) {
+  Map<TransformerId, Set<TransformerId>>
+      transformersNeededByTransformers([Iterable<TransformerId> transformers]) {
     var result = {};
 
     if (transformers == null) {
       transformers = ordered(_graph.packages.keys).expand((packageName) {
         var package = _graph.packages[packageName];
         return package.pubspec.transformers.expand((phase) {
           return phase.expand((config) {
             var id = config.id;
             if (id.isBuiltInTransformer) return [];
             if (id.package != _graph.entrypoint.root.name &&
@@ skipping 10 matching lines @@
       result[id] = _transformersNeededByTransformer(id);
     }
     return result;
   }
 
   /// Returns the set of all transformers needed to load the library identified
   /// by [id].
   Set<TransformerId> transformersNeededByLibrary(AssetId id) {
     var library = _graph.packages[id.package].path(p.fromUri(id.path));
     _loadPackageComputer(id.package);
-    return _packageComputers[id.package].transformersNeededByLibrary(library)
-        .where((id) => !id.isBuiltInTransformer).toSet();
+    return _packageComputers[id.package].transformersNeededByLibrary(
+        library).where((id) => !id.isBuiltInTransformer).toSet();
   }
 
   /// Returns the set of all transformers that need to be loaded before [id] is
   /// loaded.
   Set<TransformerId> _transformersNeededByTransformer(TransformerId id) {
     if (id.isBuiltInTransformer) return new Set();
     _loadPackageComputer(id.package);
     return _packageComputers[id.package]._transformersNeededByTransformer(id);
   }
 
   /// Returns the set of all transformers that need to be loaded before
   /// [packageUri] (a "package:" URI) can be safely imported from an external
   /// package.
   Set<TransformerId> _transformersNeededByPackageUri(Uri packageUri) {
     var components = p.split(p.fromUri(packageUri.path));
     var packageName = components.first;
     if (_untransformedPackages.contains(packageName)) return new Set();
 
     var package = _graph.packages[packageName];
     if (package == null) {
       // TODO(nweiz): include source range information here.
-      fail('A transformer imported unknown package "$packageName" (in '
-          '"$packageUri").');
+      fail(
+          'A transformer imported unknown package "$packageName" (in ' '"$packageUri").');
     }
 
     var library = package.path('lib', p.joinAll(components.skip(1)));
 
     _loadPackageComputer(packageName);
     return _packageComputers[packageName].transformersNeededByLibrary(library);
   }
 
   /// Returns the set of all transformers that need to be loaded before
   /// everything in [rootPackage] can be used.
@@ skipping 27 matching lines @@
           var id = config.id;
           if (id.isBuiltInTransformer) continue;
           if (_loadingPackageComputers.contains(id.package)) {
             throw new CycleException("$packageName is transformed by $id");
           }
           results.add(id);
         }
       }
 
       var dependencies = packageName == _graph.entrypoint.root.name ?
-          package.immediateDependencies : package.dependencies;
+          package.immediateDependencies :
+          package.dependencies;
       for (var dep in dependencies) {
         try {
           traversePackage(dep.name);
         } on CycleException catch (error) {
           throw error.prependStep("$packageName depends on ${dep.name}");
         }
       }
     }
 
     traversePackage(rootPackage);
@@ skipping 50 matching lines @@
   /// A cache of the results of [_transformersNeededByTransformer].
   final _transformersNeededByTransformers =
       new Map<TransformerId, Set<TransformerId>>();
 
   /// A cache of the results of [_getTransitiveExternalDirectives].
   ///
   /// This is invalidated whenever [_applicableTransformers] changes.
   final _transitiveExternalDirectives = new Map<String, Set<Uri>>();
 
   _PackageDependencyComputer(DependencyComputer dependencyComputer,
-          String packageName)
+      String packageName)
       : _dependencyComputer = dependencyComputer,
         _package = dependencyComputer._graph.packages[packageName] {
     // If [_package] uses its own transformers, there will be fewer transformers
     // running on [_package] while its own transformers are loading than there
     // will be once all its transformers are finished loading. To handle this,
     // we run [_transformersNeededByTransformer] to pre-populate
     // [_transformersNeededByLibraries] while [_applicableTransformers] is
     // smaller.
     for (var phase in _package.pubspec.transformers) {
       for (var config in phase) {
@@ skipping 51 matching lines @@
   Set<TransformerId> transformersNeededByLibrary(String library) {
     library = p.normalize(library);
     if (_activeLibraries.contains(library)) return new Set();
     _activeLibraries.add(library);
 
     try {
       var externalDirectives = _getTransitiveExternalDirectives(library);
       if (externalDirectives == null) {
         var rootName = _dependencyComputer._graph.entrypoint.root.name;
         var dependencies = _package.name == rootName ?
-            _package.immediateDependencies : _package.dependencies;
+            _package.immediateDependencies :
+            _package.dependencies;
 
         // If anything transitively imported/exported by [library] within this
         // package is modified by a transformer, we don't know what it will
         // load, so we take the conservative approach and say it depends on
         // everything.
-        return _applicableTransformers.map((config) => config.id).toSet().union(
-            unionAll(dependencies.map((dep) {
+        return _applicableTransformers.map(
+            (config) => config.id).toSet().union(unionAll(dependencies.map((dep) {
           try {
             return _dependencyComputer._transformersNeededByPackage(dep.name);
           } on CycleException catch (error) {
             throw error.prependStep("${_package.name} depends on ${dep.name}");
           }
         })));
       } else {
         // If nothing's transformed, then we only depend on the transformers
         // used by the external packages' libraries that we import or export.
         return unionAll(externalDirectives.map((uri) {
@@ skipping 62 matching lines @@
         traverseLibrary(rootLibrary) ? results : null;
     return _transitiveExternalDirectives[rootLibrary];
   }
 
   /// Returns the set of all imports or exports in [library].
   ///
   /// If [library] is modified by a transformer, this will return `null`.
   Set<Uri> _getDirectives(String library) {
     var libraryUri = p.toUri(p.normalize(library));
     var relative = p.toUri(_package.relative(library)).path;
-    if (_applicableTransformers.any((config) =>
-            config.canTransform(relative))) {
+    if (_applicableTransformers.any(
+        (config) => config.canTransform(relative))) {
       _directives[libraryUri] = null;
       return null;
     }
 
     // Check the cache *after* checking [_applicableTransformers] because
     // [_applicableTransformers] changes over time so the directives may be
     // invalidated.
     if (_directives.containsKey(libraryUri)) return _directives[libraryUri];
 
     // If a nonexistent library is imported, it will probably be generated by a
     // transformer.
     if (!fileExists(library)) {
       _directives[libraryUri] = null;
       return null;
     }
 
-    _directives[libraryUri] =
-        parseImportsAndExports(readTextFile(library), name: library)
-        .map((directive) => Uri.parse(directive.uri.stringValue))
-        .toSet();
+    _directives[libraryUri] = parseImportsAndExports(
+        readTextFile(library),
+        name: library).map((directive) => Uri.parse(directive.uri.stringValue)).toSet();
     return _directives[libraryUri];
   }
 }