Select packages that match SDK constraints.

utils/pub/solver/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.
 
 library version_solver;
 
 import 'dart:async';
 import 'dart:json' as json;
 
 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 '../version.dart';
 import 'backtracking_solver.dart';
 import 'greedy_solver.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].
@@ skipping 15 matching lines @@
   var solver;
   if (allowBacktracking) {
     solver = new BacktrackingVersionSolver(sources, root, lockFile, useLatest);
   } else {
     solver = new GreedyVersionSolver(sources, root, lockFile, useLatest);
   }
 
   return solver.solve();
 }
 
+/// 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) {

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

It seems really weird that this is a top-level, public function in this library.
It's just used by the two solvers, right? Not by any clients of this library? It
seems like it belongs in a utils library.

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

It was being used by both VersionSolver and BacktrackingSolver. But to keep the
old SDK constraint stuff still working, I moved it so that only
BacktrackingSolver uses it, so I just moved this into that library.

+  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}.');
+}
+
 /// Base class for an implementation of the version constraint solver.
 class VersionSolver {
   final SourceRegistry sources;
   final Package root;
   final LockFile lockFile;
   final PubspecCache cache;
 
   VersionSolver(SourceRegistry sources, this.root, this.lockFile,
                 List<String> useLatest)
       : sources = sources,
         cache = new PubspecCache(sources) {
     for (var package in useLatest) {
       forceLatestVersion(package);
       lockFile.packages.remove(package);
     }
   }
 
   /// The number of solutions the solver has tried so far.
   int get attemptedSolutions;
 
   /// Force the solver to upgrade [package] to the latest available version.
   void forceLatestVersion(String package);
 
   /// Run the solver. Completes with a list of specific package versions if
   /// successful or an error if it failed to find a solution.
   Future<SolveResult> solve() {
     var stopwatch = new Stopwatch();
-    stopwatch.start();
 
-    // Pre-cache the root package's known pubspec.
-    cache.cache(new PackageId.root(root), root.pubspec);
+    return new Future(() {
+      stopwatch.start();
 
-    return runSolver().then((packages) {
+      // Pre-cache the root package's known pubspec.
+      cache.cache(new PackageId.root(root), root.pubspec);
+
+      validateSdkConstraint(root.pubspec);
+      return runSolver();
+    }).then((packages) {
       return new SolveResult(packages, null, attemptedSolutions);
     }).catchError((error) {
       if (error is! SolveFailure) throw error;
 
       // Wrap a failure in a result so we can attach some other data.
       return new SolveResult(null, error, attemptedSolutions);
     }).whenComplete(() {
       // Gather some solving metrics.
       var buffer = new StringBuffer();
       buffer.writeln('${runtimeType} took ${stopwatch.elapsed} seconds.');
@@ skipping 205 matching lines @@
 
   /// Describes a dependencie's reference in the output message. Override this
   /// to highlight which aspect of [ref] led to the failure.
   String _describeDependency(PackageRef ref) =>
       "depends on version ${ref.constraint}";
 }
 
 /// Exception thrown when the [VersionSolver] fails to find a solution after a
 /// certain number of iterations.
 class CouldNotSolveException extends SolveFailure {
-  CouldNotSolveException()
-      : super(null, null);
+  CouldNotSolveException([String message])
+      : super(null, null),
+        _message = (message != null) ? message :
+            "Could not find a solution that met all constraints.";
 
   /// A message describing the specific kind of solve failure.
-  String get _message =>
-      "Could not find a solution that met all constraints.";
+  final String _message;
 }
 
 /// Exception thrown when the [VersionConstraint] used to match a package is
 /// valid (i.e. non-empty), but there are no available versions of the package
 /// that fit that constraint.
 class NoVersionException extends SolveFailure {
   final VersionConstraint constraint;
 
   NoVersionException(String package, this.constraint,
       Iterable<Dependency> dependencies)
@@ skipping 47 matching lines @@
       Iterable<Dependency> dependencies)
       : super(package, dependencies);
 
   String get _message => "Incompatible dependencies on '$package'";
 
   String _describeDependency(PackageRef ref) {
     // TODO(nweiz): Dump descriptions to YAML when that's supported.
     return "depends on it with description ${json.stringify(ref.description)}";
   }
 }