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 21 matching lines @@
 /// a valid solution has been found or until all possible options for all
 /// speculative choices have been exhausted.
 library version_solver2;
 
 import 'dart:async';
 import 'dart:collection' show Queue;
 
 import '../lock_file.dart';
 import '../log.dart' as log;
 import '../package.dart';
+import '../pubspec.dart';
+import '../sdk.dart' as sdk;
 import '../source.dart';
 import '../source_registry.dart';
 import '../utils.dart';
 import '../version.dart';
 import 'version_solver.dart';
 
 /// The top-level solver. Keeps track of the current potential solution, and
 /// the other possible versions for speculative package selections. Backtracks
 /// and advances to the next potential solution in the case of a failure.
 class BacktrackingVersionSolver extends VersionSolver {
@@ skipping 15 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();
+  Future<List<PackageId>> runSolver() {
+    return new Future.sync(() {
+      _validateSdkConstraint(root.pubspec);
+      return _traverseSolution();
+    });
+  }
 
   /// Adds [versions], which is the list of all allowed versions of a given
   /// package, to the set of versions to consider for solutions. The first item
   /// in the list will be the currently selected version of that package.
   /// Subsequent items will be tried if it the current selection fails. Returns
   /// the first selected version.
   PackageId select(Iterable<PackageId> versions) {
     _selected.add(new Queue<PackageId>.from(versions));
     logSolve();
     return versions.first;
@@ skipping 17 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++;
+        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 149 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 217 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;
   }
 }
+
+/// Ensures that if [pubspec] has an SDK constraint, then it is compatible
+/// with the current SDK. Throws a [SolverFailure] if not.
+void _validateSdkConstraint(Pubspec pubspec) {
+  if (pubspec.environment.sdkVersion.allows(sdk.version)) return;
+
+  throw new CouldNotSolveException(
+      'Package ${pubspec.name} requires SDK version '
+      '${pubspec.environment.sdkVersion} but the current SDK is '
+      '${sdk.version}.');
+}