Add support for specifying SDK version constraints in pubspecs.

utils/pub/version.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.
 
 /// Handles version numbers, following the [Semantic Versioning][semver] spec.
 ///
 /// [semver]: http://semver.org/
 library version;
 
 import 'dart:math';
@@ skipping 92 matching lines @@
   /// Tests if [other] matches this version exactly.
   bool allows(Version other) => this == other;
 
   VersionConstraint intersect(VersionConstraint other) {
     if (other.isEmpty) return other;
 
     // Intersect a version and a range.
     if (other is VersionRange) return other.intersect(this);
 
     // Intersecting two versions only works if they are the same.
-    if (other is Version) return this == other ? this : const _EmptyVersion();
+    if (other is Version) {
+      return this == other ? this : VersionConstraint.empty;
+    }
 
     throw new ArgumentError(
         'Unknown VersionConstraint type $other.');
   }
 
   int compareTo(Version other) {
     if (major != other.major) return major.compareTo(other.major);
     if (minor != other.minor) return minor.compareTo(other.minor);
     if (patch != other.patch) return patch.compareTo(other.patch);
 
@@ skipping 75 matching lines @@
       }
     }).toList();
   }
 }
 
 /// A [VersionConstraint] is a predicate that can determine whether a given
 /// version is valid or not. For example, a ">= 2.0.0" constraint allows any
 /// version that is "2.0.0" or greater. Version objects themselves implement
 /// this to match a specific version.
 abstract class VersionConstraint {
+  /// A [VersionConstraint] that allows all versions.
+  static VersionConstraint any = new VersionRange();
+
   /// A [VersionConstraint] that allows no versions: i.e. the empty set.
-  factory VersionConstraint.empty() => const _EmptyVersion();
+  static VersionConstraint empty = const _EmptyVersion();
 
   /// Parses a version constraint. This string is a space-separated series of
   /// version parts. Each part can be one of:
   ///
   ///   * A version string like `1.2.3`. In other words, anything that can be
   ///     parsed by [Version.parse()].
   ///   * A comparison operator (`<`, `>`, `<=`, or `>=`) followed by a version
   ///     string. There cannot be a space between the operator and the version.
   ///
   /// Examples:
@@ skipping 105 matching lines @@
     if (min != null && !includeMin && other == min) return false;
     if (max != null && other > max) return false;
     if (max != null && !includeMax && other == max) return false;
     return true;
   }
 
   VersionConstraint intersect(VersionConstraint other) {
     if (other.isEmpty) return other;
 
     // A range and a Version just yields the version if it's in the range.
-    if (other is Version) return allows(other) ? other : const _EmptyVersion();
+    if (other is Version) {
+      return allows(other) ? other : VersionConstraint.empty;
+    }
 
     if (other is VersionRange) {
       // Intersect the two ranges.
       var intersectMin = min;
       var intersectIncludeMin = includeMin;
       var intersectMax = max;
       var intersectIncludeMax = includeMax;
 
       if (other.min == null) {
         // Do nothing.
@@ skipping 19 matching lines @@
         // Open range.
         return new VersionRange();
       }
 
       // If the range is just a single version.
       if (intersectMin == intersectMax) {
         // If both ends are inclusive, allow that version.
         if (intersectIncludeMin && intersectIncludeMax) return intersectMin;
 
         // Otherwise, no versions.
-        return const _EmptyVersion();
+        return VersionConstraint.empty;
       }
 
       if (intersectMin != null && intersectMax != null &&
           intersectMin > intersectMax) {
         // Non-overlapping ranges, so empty.
-        return const _EmptyVersion();
+        return VersionConstraint.empty;
       }
 
       // If we got here, there is an actual range.
       return new VersionRange(min: intersectMin, max: intersectMax,
           includeMin: intersectIncludeMin, includeMax: intersectIncludeMax);
     }
 
     throw new ArgumentError(
         'Unknown VersionConstraint type $other.');
   }
@@ skipping 19 matching lines @@
 
 class _EmptyVersion implements VersionConstraint {
   const _EmptyVersion();
 
   bool get isEmpty => true;
   bool get isAny => false;
   bool allows(Version other) => false;
   VersionConstraint intersect(VersionConstraint other) => this;
   String toString() => '<empty>';
 }