Select packages that match SDK constraints.

utils/pub/solver/backtracking_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.
 
 /// A back-tracking depth-first solver. Attempts to find the best solution for
 /// a root package's transitive dependency graph, where a "solution" is a set
 /// of concrete package versions. A valid solution will select concrete
 /// versions for every package reached from the root package's dependency graph,
 /// and each of those packages will fit the version constraints placed on it.
 ///
@@ skipping 56 matching lines @@
   ///
   /// The solver tries versions in depth-first order, so only the last queue in
   /// the list will have items removed from it. When a new constraint is placed
   /// on an already-selected package, and that constraint doesn't match the
   /// selected version, that will cause the current solution to fail and
   /// trigger backtracking.
   final _selected = <Queue<PackageId>>[];
 
   /// The number of possible solutions that have been attempted.
   int get attemptedSolutions => _attemptedSolutions;
-  var _attemptedSolutions = 0;
+  var _attemptedSolutions = 1;
 
   BacktrackingVersionSolver(SourceRegistry sources, Package root,
       LockFile lockFile, List<String> useLatest)
       : super(sources, root, lockFile, useLatest);
 
   void forceLatestVersion(String package) {
     _forceLatest.add(package);
   }
 
   Future<List<PackageId>> runSolver() => _traverseSolution();
@@ skipping 27 matching lines @@
   /// `null` if it isn't in the lockfile (or has been unlocked).
   PackageId getLocked(String package) => lockFile.packages[package];
 
   /// Traverses the root package's dependency graph using the current potential
   /// solution. If successful, completes to the solution. If not, backtracks
   /// to the most recently selected version of a package and tries the next
   /// version of it. If there are no more versions, continues to backtrack to
   /// previous selections, and so on. If there is nothing left to backtrack to,
   /// completes to the last failure that occurred.
   Future<List<PackageId>> _traverseSolution() {
-    _attemptedSolutions++;
-
     return new Traverser(this).traverse().catchError((error) {
       if (error is! SolveFailure) throw error;
 
-      if (_backtrack(error)) return _traverseSolution();
+      if (_backtrack(error)) {
+        _attemptedSolutions++;

[nweiz, 2013/04/16 23:52:32]

Why is this moving in here? Won't this just decrement the reported number of
solutions by 1? It doesn't look like you've adjusted the maxTries flags on the
tests accordingly.

[Bob Nystrom, 2013/04/17 17:28:44]

This handles a weird little corner case. If the root package's SDK constraint
does not match the current SDK, then VersionSolver will report an error before
ever calling _traverseSolution(). This meant that in that case, it would return
a SolveResult with 0 attempted solutions instead of 1.

So this change ensures the attempted solutions always start at 1.
It would except the initializer for _attemptedSolutions now starts it at 1.
The end result is the same.

+        return _traverseSolution();
+      }
 
       // All out of solutions, so fail.
       throw error;
     });
   }
 
   /// Backtracks from the current failed solution and determines the next
   /// solution to try. If possible, it will backjump based on the cause of the
   /// [failure] to minize backtracking. Otherwise, it will simply backtrack to
   /// the next possible solution.
@@ skipping 159 matching lines @@
 
     var id = _packages.removeFirst();
 
     // Don't visit the same package twice.
     if (_visited.contains(id)) {
       return _traversePackage();
     }
     _visited.add(id);
 
     return _solver.cache.getPubspec(id).then((pubspec) {
+      validateSdkConstraint(pubspec);
+
       var refs = pubspec.dependencies.toList();
 
       // Include dev dependencies of the root package.
       if (id.isRoot) refs.addAll(pubspec.devDependencies);
 
       // Given a package ref, returns a future that completes to a pair of the
       // ref and the number of versions available for it.
       getNumVersions(PackageRef ref) {
         // There is only ever one version of the root package.
         if (ref.isRoot) {
@@ skipping 213 matching lines @@
 
     var required = _getRequired(name);
     if (required != null) {
       if (package.source.name != required.ref.source.name) return null;
       if (!package.descriptionEquals(required.ref)) return null;
     }
 
     return package;
   }
 }