Reverting 9767.

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
@@ skipping 20 matching lines @@
  * 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('lock_file.dart');
 #import('package.dart');
 #import('pubspec.dart');
 #import('root_source.dart');
 #import('source.dart');
 #import('source_registry.dart');
 #import('utils.dart');
 #import('version.dart');
 
 /**
  * Attempts to select the best concrete versions for all of the transitive
  * dependencies of [root] taking into account all of the [VersionConstraint]s
- * that those dependencies place on each other and the requirements imposed by
- * [lockFile]. If successful, completes to a [Map] that maps package names to
- * the selected version for that package. If it fails, the future will complete
- * with a [NoVersionException], [DisjointConstraintException], or
- * [CouldNotSolveException].
+ * that those dependencies place on each other. If successful, completes to a
+ * [Map] that maps package names to the selected version for that package. If
+ * it fails, the future will complete with a [NoVersionException],
+ * [DisjointConstraintException], or [CouldNotSolveException].
  */
-Future<List<PackageId>> resolveVersions(SourceRegistry sources, Package root,
-    LockFile lockFile) {
-  return new VersionSolver(sources, root, lockFile).solve();
+Future<List<PackageId>> resolveVersions(SourceRegistry sources, Package root) {
+  return new VersionSolver(sources, root).solve();
 }
 
 class VersionSolver {
   final SourceRegistry _sources;
   final Package _root;
-  final LockFile lockFile;
   final PubspecCache _pubspecs;
   final Map<String, Dependency> _packages;
   final Queue<WorkItem> _work;
   int _numIterations = 0;
 
-  VersionSolver(SourceRegistry sources, this._root, this.lockFile)
+  VersionSolver(SourceRegistry sources, Package root)
       : _sources = sources,
+        _root = root,
         _pubspecs = new PubspecCache(sources),
         _packages = <Dependency>{},
         _work = new Queue<WorkItem>();
 
   Future<List<PackageId>> solve() {
     // Kick off the work by adding the root package at its concrete version to
     // the dependency graph.
     var ref = new PackageRef(new RootSource(_root), _root.version, _root.name);
     enqueue(new AddConstraint('(entrypoint)', ref));
     _pubspecs.cache(ref.atVersion(_root.version), _root.pubspec);
@@ skipping 40 matching lines @@
   }
 
   /**
    * Sets the best selected version of [package] to [version].
    */
   void setVersion(String package, Version version) {
     _packages[package].version = version;
   }
 
   List<PackageId> buildResults() {
-    return _packages.getValues().filter((dep) => dep.isDependedOn).map((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.source, dep.version, description);
-    });
+    return _packages.getValues()
+      .filter((dep) => dep.isDependedOn)
+      .map((dep) => new PackageId(dep.source, dep.version, dep.description));
   }
 }
 
 /**
  * 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.
 */
 interface WorkItem {
@@ skipping 123 matching lines @@
     }
 
     // If the dependency is on the root package, then we don't need to do
     // anything since it's already at the best version.
     if (name == solver._root.name) {
       solver.enqueue(new ChangeVersion(
           source, description, solver._root.version));
       return null;
     }
 
-    // If the dependency is on a package in the lockfile, use the lockfile's
-    // version for that package if it's valid given the other constraints.
-    var lockedPackage = solver.lockFile.packages[name];
-    if (lockedPackage != null) {
-      var lockedVersion = lockedPackage.version;
-      if (newConstraint.allows(lockedVersion)) {
-        solver.enqueue(new ChangeVersion(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 source.getVersions(description).transform((versions) {
       var best = null;
       for (var version in versions) {
         if (newConstraint.allows(version)) {
           if (best == null || version > best) best = version;
         }
       }
 
@@ skipping 258 matching lines @@
   final description1;
   final description2;
 
   DescriptionMismatchException(this.package, this.description1,
       this.description2);
 
   // TODO(nweiz): Dump to YAML when that's supported
   String toString() => "Package '$package' has conflicting descriptions "
     "'${JSON.stringify(description1)}' and '${JSON.stringify(description2)}'";
 }