Big merge from experimental to bleeding edge.

utils/pub/version_solver.dart

 // Copyright (c) 2012, 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.
 
 /// Attempts to resolve a set of version constraints for a package dependency
 /// graph and select an appropriate set of best specific versions for all
 /// dependent packages. It works iteratively and tries to reach a stable
 /// solution where the constraints of all dependencies are met. If it fails to
 /// reach a solution after a certain number of iterations, it assumes the
 /// dependency graph is unstable and reports and error.
@@ skipping 17 matching lines @@
 /// When a constraint on a package changes, we re-calculate the overall
 /// constraint on that package. I.e. with a shared dependency, we intersect all
 /// of the constraints that its depending packages place on it. If that overall
 /// constraint changes (say from "<3.0.0" to "<2.5.0"), then the currently
 /// picked version for that package may fall outside of the new constraint. If
 /// that happens, we find the new best version that meets the updated constraint
 /// and then the change the package to use that version. That cycles back up to
 /// the beginning again.
 library version_solver;
 
-import 'dart:json';
+import 'dart:async';
+import 'dart:json' as json;
 import 'dart:math';
 import 'lock_file.dart';
 import 'log.dart' as log;
 import 'package.dart';
 import 'pubspec.dart';
 import 'root_source.dart';
 import 'source.dart';
 import 'source_registry.dart';
 import 'utils.dart';
 import 'version.dart';
@@ skipping 60 matching lines @@
         if (_numIterations > max(50, _packages.length * 5)) {
           throw new CouldNotSolveException();
         }
 
         // Run the first work item.
         var future = _work.removeFirst().process(this);
 
         // If we have an async operation to perform, chain the loop to resume
         // when it's done. Otherwise, just loop synchronously.
         if (future != null) {
-          return future.chain(processNextWorkItem);
+          return future.then(processNextWorkItem);
         }
       }
     }
 
     return processNextWorkItem(null);
   }
 
   void enqueue(WorkItem work) {
     _work.add(work);
   }
 
   Dependency getDependency(String package) {
     // There can be unused dependencies in the graph, so just create an empty
     // one if needed.
     _packages.putIfAbsent(package, () => new Dependency(package));
     return _packages[package];
   }
 
   /// Sets the best selected version of [package] to [version].
   void setVersion(String package, Version version) {
     _packages[package].version = version;
   }
 
   /// Returns the most recent version of [dependency] that satisfies all of its
   /// version constraints.
   Future<Version> getBestVersion(Dependency dependency) {
-    return dependency.getVersions().transform((versions) {
+    return dependency.getVersions().then((versions) {
       var best = null;
       for (var version in versions) {
         if (dependency.useLatestVersion ||
             dependency.constraint.allows(version)) {
           if (best == null || version > best) best = version;
         }
       }
 
       // TODO(rnystrom): Better exception.
       if (best == null) {
@@ skipping 25 matching lines @@
 
     for (var dependerName in dependency.dependers) {
       var depender = getDependency(dependerName);
       var locked = lockFile.packages[dependerName];
       if (locked != null && depender.version == locked.version) {
         enqueue(new UnlockPackage(depender));
         return true;
       }
     }
 
-    return dependency.dependers.map(getDependency).some((subdependency) =>
+    return dependency.dependers.mappedBy(getDependency).any((subdependency) =>
         tryUnlockDepender(subdependency, seen));
   }
 
   List<PackageId> buildResults() {
-    return _packages.values.filter((dep) => dep.isDependedOn).map((dep) {
+    return _packages.values.where((dep) => dep.isDependedOn).mappedBy((dep) {
       var description = dep.description;
 
       // If the lockfile contains a fully-resolved description for the package,
       // use that. This allows e.g. Git to ensure that the same commit is used.
       var lockedPackage = lockFile.packages[dep.name];
       if (lockedPackage != null && lockedPackage.version == dep.version &&
           lockedPackage.source.name == dep.source.name &&
           dep.source.descriptionsEqual(
               description, lockedPackage.description)) {
         description = lockedPackage.description;
       }
 
       return new PackageId(dep.name, dep.source, dep.version, description);
-    });
+    })
+    .toList();
   }
 }
 
 /// The constraint solver works by iteratively processing a queue of work items.
 /// Each item is a single atomic change to the dependency graph. Handling them
 /// in a queue lets us handle asynchrony (resolving versions requires
 /// information from servers) as well as avoid deeply nested recursion.
 abstract class WorkItem {
   /// Processes this work item. Returns a future that completes when the work is
   /// done. If `null` is returned, that means the work has completed
@@ skipping 25 matching lines @@
     log.fine("Changing $package to version $version.");
 
     var dependency = solver.getDependency(package);
     var oldVersion = dependency.version;
     solver.setVersion(package, version);
 
     // The dependencies between the old and new version may be different. Walk
     // them both and update any constraints that differ between the two.
     return Futures.wait([
         getDependencyRefs(solver, oldVersion),
-        getDependencyRefs(solver, version)]).transform((list) {
+        getDependencyRefs(solver, version)]).then((list) {
       var oldDependencyRefs = list[0];
       var newDependencyRefs = list[1];
 
       for (var oldRef in oldDependencyRefs.values) {
         if (newDependencyRefs.containsKey(oldRef.name)) {
           // The dependency is in both versions of this package, but its
           // constraint may have changed.
           var newRef = newDependencyRefs.remove(oldRef.name);
           solver.enqueue(new AddConstraint(package, newRef));
         } else {
@@ skipping 14 matching lines @@
   /// Get the dependencies at [version] of the package being changed.
   Future<Map<String, PackageRef>> getDependencyRefs(VersionSolver solver,
       Version version) {
     // If there is no version, it means no package, so no dependencies.
     if (version == null) {
       return
           new Future<Map<String, PackageRef>>.immediate(<String, PackageRef>{});
     }
 
     var id = new PackageId(package, source, version, description);
-    return solver._pubspecs.load(id).transform((pubspec) {
+    return solver._pubspecs.load(id).then((pubspec) {
       var dependencies = <String, PackageRef>{};
       for (var dependency in pubspec.dependencies) {
         dependencies[dependency.name] = dependency;
       }
       return dependencies;
     });
   }
 }
 
 /// A constraint that a depending package places on a dependent package has
@@ skipping 54 matching lines @@
       var lockedVersion = lockedPackage.version;
       if (newConstraint.allows(lockedVersion)) {
         solver.enqueue(
             new ChangeVersion(name, source, description, lockedVersion));
         return null;
       }
     }
 
     // The constraint has changed, so see what the best version of the package
     // that meets the new constraint is.
-    return solver.getBestVersion(newDependency).transform((best) {
+    return solver.getBestVersion(newDependency).then((best) {
       if (best == null) {
         undo(solver);
       } else if (newDependency.version != best) {
         solver.enqueue(new ChangeVersion(name, source, description, best));
       }
     });
   }
 }
 
 /// The constraint given by [ref] is being placed by [depender].
@@ skipping 53 matching lines @@
 class UnlockPackage implements WorkItem {
   /// The package being unlocked.
   Dependency package;
 
   UnlockPackage(this.package);
 
   Future process(VersionSolver solver) {
     log.fine("Unlocking ${package.name}.");
 
     solver.lockFile.packages.remove(package.name);
-    return solver.getBestVersion(package).transform((best) {
+    return solver.getBestVersion(package).then((best) {
       if (best == null) return null;
       solver.enqueue(new ChangeVersion(
           package.name, package.source, package.description, best));
     });
   }
 }
 
 // TODO(rnystrom): Instead of always pulling from the source (which will mean
 // hitting a server), we should consider caching pubspecs of uninstalled
 // packages in the system cache.
@@ skipping 11 matching lines @@
     _pubspecs[id] = pubspec;
   }
 
   /// Loads the pubspec for the package identified by [id].
   Future<Pubspec> load(PackageId id) {
     // Complete immediately if it's already cached.
     if (_pubspecs.containsKey(id)) {
       return new Future<Pubspec>.immediate(_pubspecs[id]);
     }
 
-    return id.describe().transform((pubspec) {
+    return id.describe().then((pubspec) {
       // Cache it.
       _pubspecs[id] = pubspec;
       return pubspec;
     });
   }
 }
 
 /// Describes one [Package] in the [DependencyGraph] and keeps track of which
 /// packages depend on it and what constraints they place on it.
 class Dependency {
   /// The name of the this dependency's package.
   final String name;
 
   /// The [PackageRefs] that represent constraints that depending packages have
   /// placed on this one.
   final Map<String, PackageRef> _refs;
 
   /// The currently-selected best version for this dependency.
   Version version;
 
   /// Whether this dependency should always select the latest version.
   bool useLatestVersion = false;
 
   /// Gets whether or not any other packages are currently depending on this
   /// one. If `false`, then it means this package is not part of the dependency
   /// graph and should be omitted.
   bool get isDependedOn => !_refs.isEmpty;
 
   /// The names of all the packages that depend on this dependency.
-  Collection<String> get dependers => _refs.keys;
+  Iterable<String> get dependers => _refs.keys;
 
   /// Gets the overall constraint that all packages are placing on this one.
   /// If no packages have a constraint on this one (which can happen when this
   /// package is in the process of being added to the graph), returns `null`.
   VersionConstraint get constraint {
     if (_refs.isEmpty) return null;
     return new VersionConstraint.intersection(
-        _refs.values.map((ref) => ref.constraint));
+        _refs.values.mappedBy((ref) => ref.constraint));
   }
 
   /// The source of this dependency's package.
   Source get source {
      var canonical = _canonicalRef();
      if (canonical == null) return null;
      return canonical.source;
   }
 
   /// The description of this dependency's package.
   get description {
      var canonical = _canonicalRef();
      if (canonical == null) return null;
      return canonical.description;
   }
 
   /// Return the PackageRef that has the canonical source and description for
   /// this package. If any dependency requires that this package come from a
   /// [RootSource], that will be used; otherwise, it will be the source and
   /// description that all dependencies agree upon.
   PackageRef _canonicalRef() {
     if (_refs.isEmpty) return null;
     var refs = _refs.values;
     for (var ref in refs) {
       if (ref is RootSource) return ref;
     }
-    return refs[0];
+    return refs.first;
   }
 
   Dependency(this.name)
       : _refs = <String, PackageRef>{};
 
   Dependency._clone(Dependency other)
       : name = other.name,
         version = other.version,
         _refs = new Map<String, PackageRef>.from(other._refs);
 
@@ skipping 20 matching lines @@
 
     _refs[package] = ref;
   }
 
   /// Returns the name of a package whose constraint source and description
   /// all other constraints must match. Returns null if there are no
   /// requirements on new constraints.
   String _requiredDepender() {
     if (_refs.isEmpty) return null;
 
-    var dependers = _refs.keys;
+    var dependers = _refs.keys.toList();
     if (dependers.length == 1) {
       var depender = dependers[0];
       if (_refs[depender].source is RootSource) return null;
       return depender;
     }
 
     return dependers[1];
   }
 
   /// Removes the constraint from [package] onto this.
@@ skipping 103 matching lines @@
   final String depender2;
   final description2;
 
   DescriptionMismatchException(this.package, this.depender1, this.description1,
       this.depender2, this.description2);
 
   String toString() {
     // TODO(nweiz): Dump descriptions to YAML when that's supported.
     return "Incompatible dependencies on '$package':\n"
         "- '$depender1' depends on it with description "
-        "${JSON.stringify(description1)}\n"
+        "${json.stringify(description1)}\n"
         "- '$depender2' depends on it with description "
-        "${JSON.stringify(description2)}";
+        "${json.stringify(description2)}";
   }
 }