Update Version to latest language changes.

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;
@@ skipping 179 matching lines @@
     });
   }
 }
 
 /**
  * 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.
  */
-interface VersionConstraint default _VersionConstraintFactory {
+abstract class VersionConstraint {
   /**
    * A [VersionConstraint] that allows no versions: i.e. the empty set.
    */
-  VersionConstraint.empty();
+  factory 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:
    *
    *     1.2.3-alpha
    *     <=5.1.4
    *     >2.0.4 <=2.4.6
    */
-  VersionConstraint.parse(String text);
+  factory VersionConstraint.parse(String text) {
+    if (text.trim() == '') {
+      throw new FormatException('Cannot parse an empty string.');
+    }
+
+    // Split it into space-separated parts.
+    var constraints = <VersionConstraint>[];
+    for (var part in text.split(' ')) {
+      constraints.add(_parseSingleConstraint(part));
+    }
+
+    return new VersionConstraint.intersection(constraints);
+  }
 
   /**
    * Creates a new version constraint that is the intersection of [constraints].
    * It will only allow versions that all of those constraints allow. If
    * constraints is empty, then it returns a VersionConstraint that allows all
    * versions.
    */
-  VersionConstraint.intersect(Collection<VersionConstraint> constraints);
+  factory VersionConstraint.intersection(
+      Collection<VersionConstraint> constraints) {
+    var constraint = new VersionRange();
+    for (var other in constraints) {
+      constraint = constraint.intersect(other);
+    }
+    return constraint;
+  }
 
   /**
    * Returns `true` if this constraint allows no versions.
    */
   bool get isEmpty;
 
   /**
    * Returns `true` if this constraint allows [version].
    */
   bool allows(Version version);
 
   /**
    * Creates a new [VersionConstraint] that only allows [Version]s allowed by
    * both this and [other].
    */
   VersionConstraint intersect(VersionConstraint other);
+
+  static VersionConstraint _parseSingleConstraint(String text) {
+    if (text == 'any') {
+      return new VersionRange();
+    }
+
+    // TODO(rnystrom): Consider other syntaxes for version constraints. This
+    // one is whitespace sensitive (you can't do "< 1.2.3") and "<" is
+    // unfortunately meaningful in YAML, requiring it to be quoted in a
+    // pubspec.
+    // See if it's a comparison operator followed by a version, like ">1.2.3".
+    var match = new RegExp(r"^([<>]=?)?(.*)$").firstMatch(text);
+    if (match != null) {
+      var comparison = match[1];
+      var version = new Version.parse(match[2]);
+      switch (match[1]) {
+        case '<=': return new VersionRange(max: version, includeMax: true);
+        case '<': return new VersionRange(max: version, includeMax: false);
+        case '>=': return new VersionRange(min: version, includeMin: true);
+        case '>': return new VersionRange(min: version, includeMin: false);
+      }
+    }
+
+    // Otherwise, it must be an explicit version.
+    return new Version.parse(text);
+  }
 }
 
 /**
  * Constrains versions to a fall within a given range. If there is a minimum,
  * then this only allows versions that are at that minimum or greater. If there
  * is a maximum, then only versions less than that are allowed. In other words,
  * this allows `>= min, < max`.
  */
 class VersionRange implements VersionConstraint {
   final Version min;
@@ skipping 111 matching lines @@
 }
 
 class _EmptyVersion implements VersionConstraint {
   const _EmptyVersion();
 
   bool get isEmpty => true;
   bool allows(Version other) => false;
   VersionConstraint intersect(VersionConstraint other) => this;
   String toString() => '<empty>';
 }
-
-class _VersionConstraintFactory {
-  factory VersionConstraint.empty() => const _EmptyVersion();
-
-  factory VersionConstraint.parse(String text) {
-    if (text.trim() == '') {
-      throw new FormatException('Cannot parse an empty string.');
-    }
-
-    // Split it into space-separated parts.
-    var constraints = <VersionConstraint>[];
-    for (var part in text.split(' ')) {
-      constraints.add(parseSingleConstraint(part));
-    }
-
-    return new VersionConstraint.intersect(constraints);
-  }
-
-  factory VersionConstraint.intersect(
-      Collection<VersionConstraint> constraints) {
-    var constraint = new VersionRange();
-    for (var other in constraints) {
-      constraint = constraint.intersect(other);
-    }
-    return constraint;
-  }
-
-  static VersionConstraint parseSingleConstraint(String text) {
-    if (text == 'any') {
-      return new VersionRange();
-    }
-
-    // TODO(rnystrom): Consider other syntaxes for version constraints. This
-    // one is whitespace sensitive (you can't do "< 1.2.3") and "<" is
-    // unfortunately meaningful in YAML, requiring it to be quoted in a
-    // pubspec.
-    // See if it's a comparison operator followed by a version, like ">1.2.3".
-    var match = new RegExp(r"^([<>]=?)?(.*)$").firstMatch(text);
-    if (match != null) {
-      var comparison = match[1];
-      var version = new Version.parse(match[2]);
-      switch (match[1]) {
-        case '<=': return new VersionRange(max: version, includeMax: true);
-        case '<': return new VersionRange(max: version, includeMax: false);
-        case '>=': return new VersionRange(min: version, includeMin: true);
-        case '>': return new VersionRange(min: version, includeMin: false);
-      }
-    }
-
-    // Otherwise, it must be an explicit version.
-    return new Version.parse(text);
-  }
-}