Big merge from experimental to bleeding edge.

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 39 matching lines @@
   }
 
   /// Creates a new [Version] by parsing [text].
   factory Version.parse(String text) {
     final match = _PARSE_REGEX.firstMatch(text);
     if (match == null) {
       throw new FormatException('Could not parse "$text".');
     }
 
     try {
-      int major = parseInt(match[1]);
-      int minor = parseInt(match[2]);
-      int patch = parseInt(match[3]);
+      int major = int.parse(match[1]);
+      int minor = int.parse(match[2]);
+      int patch = int.parse(match[3]);
 
       String preRelease = match[5];
       String build = match[8];
 
       return new Version(major, minor, patch, pre: preRelease, build: build);
     } on FormatException catch (ex) {
       throw new FormatException('Could not parse "$text".');
     }
   }
 
@@ skipping 110 matching lines @@
             return aPart.compareTo(bPart);
           }
         }
       }
     }
   }
 
   /// Splits a string of dot-delimited identifiers into their component parts.
   /// Identifiers that are numeric are converted to numbers.
   List _splitParts(String text) {
-    return text.split('.').map((part) {
+    return text.split('.').mappedBy((part) {
       try {
-        return parseInt(part);
+        return int.parse(part);
       } on FormatException catch (ex) {
         // Not a number.
         return part;
       }
-    });
+    }).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 no versions: i.e. the empty set.
   factory VersionConstraint.empty() => const _EmptyVersion();
@@ skipping 23 matching lines @@
     }
 
     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.
   factory VersionConstraint.intersection(
-      Collection<VersionConstraint> constraints) {
+      Iterable<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;
 
@@ skipping 157 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>';
 }