Store the async-await compiled pub code directly in the repo.

sdk/lib/_internal/pub_generated/lib/src/version.dart

Index: sdk/lib/_internal/pub_generated/lib/src/version.dart
diff --git a/sdk/lib/_internal/pub/lib/src/version.dart b/sdk/lib/_internal/pub_generated/lib/src/version.dart
similarity index 51%
copy from sdk/lib/_internal/pub/lib/src/version.dart
copy to sdk/lib/_internal/pub_generated/lib/src/version.dart
index b68c3eda4a854ef7e4822f1b5336c195ed90353e..215b8af7be80975187c9022516a6717910e13808 100644
--- a/sdk/lib/_internal/pub/lib/src/version.dart
+++ b/sdk/lib/_internal/pub_generated/lib/src/version.dart
@@ -1,375 +1,191 @@
-// 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 pub.version;
-
 import 'dart:math';
-
 import 'package:collection/equality.dart';
-
-/// Regex that matches a version number at the beginning of a string.
 final _START_VERSION = new RegExp(
-    r'^'                                        // Start at beginning.
-    r'(\d+).(\d+).(\d+)'                        // Version number.
-    r'(-([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?'    // Pre-release.
-    r'(\+([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?'); // Build.
-
-/// Like [_START_VERSION] but matches the entire string.
+    r'^' r'(\d+).(\d+).(\d+)' r'(-([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?'
+        r'(\+([0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*))?');
 final _COMPLETE_VERSION = new RegExp("${_START_VERSION.pattern}\$");
-
-/// Parses a comparison operator ("<", ">", "<=", or ">=") at the beginning of
-/// a string.
 final _START_COMPARISON = new RegExp(r"^[<>]=?");
-
-/// The equality operator to use for comparing version components.
 final _equality = const IterableEquality();
-
-/// A parsed semantic version number.
 class Version implements Comparable<Version>, VersionConstraint {
-  /// No released version: i.e. "0.0.0".
   static Version get none => new Version(0, 0, 0);
-
-  /// Compares [a] and [b] to see which takes priority over the other.
-  ///
-  /// Returns `1` if [a] takes priority over [b] and `-1` if vice versa. If
-  /// [a] and [b] are equivalent, returns `0`.
-  ///
-  /// Unlike [compareTo], which *orders* versions, this determines which
-  /// version a user is likely to prefer. In particular, it prioritizes
-  /// pre-release versions lower than stable versions, regardless of their
-  /// version numbers.
-  ///
-  /// When used to sort a list, orders in ascending priority so that the
-  /// highest priority version is *last* in the result.
   static int prioritize(Version a, Version b) {
-    // Sort all prerelease versions after all normal versions. This way
-    // the solver will prefer stable packages over unstable ones.
     if (a.isPreRelease && !b.isPreRelease) return -1;
     if (!a.isPreRelease && b.isPreRelease) return 1;
-
     return a.compareTo(b);
   }
-
-  /// Like [proiritize], but lower version numbers are considered greater than
-  /// higher version numbers.
-  ///
-  /// This still considers prerelease versions to be lower than non-prerelease
-  /// versions.
   static int antiPrioritize(Version a, Version b) {
     if (a.isPreRelease && !b.isPreRelease) return -1;
     if (!a.isPreRelease && b.isPreRelease) return 1;
-
     return b.compareTo(a);
   }
-
-  /// The major version number: "1" in "1.2.3".
   final int major;
-
-  /// The minor version number: "2" in "1.2.3".
   final int minor;
-
-  /// The patch version number: "3" in "1.2.3".
   final int patch;
-
-  /// The pre-release identifier: "foo" in "1.2.3-foo".
-  ///
-  /// This is split into a list of components, each of which may be either a
-  /// string or a non-negative integer. It may also be empty, indicating that
-  /// this version has no pre-release identifier.
   final List preRelease;
-
-  /// The build identifier: "foo" in "1.2.3+foo".
-  ///
-  /// This is split into a list of components, each of which may be either a
-  /// string or a non-negative integer. It may also be empty, indicating that
-  /// this version has no build identifier.
   final List build;
-
-  /// The original string representation of the version number.
-  ///
-  /// This preserves textual artifacts like leading zeros that may be left out
-  /// of the parsed version.
   final String _text;
-
   Version._(this.major, this.minor, this.patch, String preRelease, String build,
-            this._text)
+      this._text)
       : preRelease = preRelease == null ? [] : _splitParts(preRelease),
         build = build == null ? [] : _splitParts(build) {
-    if (major < 0) throw new ArgumentError(
-        'Major version must be non-negative.');
-    if (minor < 0) throw new ArgumentError(
-        'Minor version must be non-negative.');
-    if (patch < 0) throw new ArgumentError(
-        'Patch version must be non-negative.');
+    if (major <
+        0) throw new ArgumentError('Major version must be non-negative.');
+    if (minor <
+        0) throw new ArgumentError('Minor version must be non-negative.');
+    if (patch <
+        0) throw new ArgumentError('Patch version must be non-negative.');
   }
-
-  /// Creates a new [Version] object.
   factory Version(int major, int minor, int patch, {String pre, String build}) {
     var text = "$major.$minor.$patch";
     if (pre != null) text += "-$pre";
     if (build != null) text += "+$build";
-
     return new Version._(major, minor, patch, pre, build, text);
   }
-
-  /// Creates a new [Version] by parsing [text].
   factory Version.parse(String text) {
     final match = _COMPLETE_VERSION.firstMatch(text);
     if (match == null) {
       throw new FormatException('Could not parse "$text".');
     }
-
     try {
       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, preRelease, build, text);
     } on FormatException catch (ex) {
       throw new FormatException('Could not parse "$text".');
     }
   }
-
-  /// Returns the primary version out of a list of candidates.
-  ///
-  /// This is the highest-numbered stable (non-prerelease) version. If there
-  /// are no stable versions, it's just the highest-numbered version.
   static Version primary(List<Version> versions) {
     var primary;
     for (var version in versions) {
-      if (primary == null || (!version.isPreRelease && primary.isPreRelease) ||
+      if (primary == null ||
+          (!version.isPreRelease && primary.isPreRelease) ||
           (version.isPreRelease == primary.isPreRelease && version > primary)) {
         primary = version;
       }
     }
     return primary;
   }
-
-  /// Splits a string of dot-delimited identifiers into their component parts.
-  ///
-  /// Identifiers that are numeric are converted to numbers.
   static List _splitParts(String text) {
     return text.split('.').map((part) {
       try {
         return int.parse(part);
       } on FormatException catch (ex) {
-        // Not a number.
         return part;
       }
     }).toList();
   }
-
   bool operator ==(other) {
     if (other is! Version) return false;
-    return major == other.major && minor == other.minor &&
+    return major == other.major &&
+        minor == other.minor &&
         patch == other.patch &&
         _equality.equals(preRelease, other.preRelease) &&
         _equality.equals(build, other.build);
   }
-
-  int get hashCode => major ^ minor ^ patch ^ _equality.hash(preRelease) ^
-      _equality.hash(build);
-
+  int get hashCode =>
+      major ^ minor ^ patch ^ _equality.hash(preRelease) ^ _equality.hash(build);
   bool operator <(Version other) => compareTo(other) < 0;
   bool operator >(Version other) => compareTo(other) > 0;
   bool operator <=(Version other) => compareTo(other) <= 0;
   bool operator >=(Version other) => compareTo(other) >= 0;
-
   bool get isAny => false;
   bool get isEmpty => false;
-
-  /// Whether or not this is a pre-release version.
   bool get isPreRelease => preRelease.isNotEmpty;
-
-  /// Gets the next major version number that follows this one.
-  ///
-  /// If this version is a pre-release of a major version release (i.e. the
-  /// minor and patch versions are zero), then it just strips the pre-release
-  /// suffix. Otherwise, it increments the major version and resets the minor
-  /// and patch.
   Version get nextMajor {
     if (isPreRelease && minor == 0 && patch == 0) {
       return new Version(major, minor, patch);
     }
-
     return new Version(major + 1, 0, 0);
   }
-
-  /// Gets the next minor version number that follows this one.
-  ///
-  /// If this version is a pre-release of a minor version release (i.e. the
-  /// patch version is zero), then it just strips the pre-release suffix.
-  /// Otherwise, it increments the minor version and resets the patch.
   Version get nextMinor {
     if (isPreRelease && patch == 0) {
       return new Version(major, minor, patch);
     }
-
     return new Version(major, minor + 1, 0);
   }
-
-  /// Gets the next patch version number that follows this one.
-  ///
-  /// If this version is a pre-release, then it just strips the pre-release
-  /// suffix. Otherwise, it increments the patch version.
   Version get nextPatch {
     if (isPreRelease) {
       return new Version(major, minor, patch);
     }
-
     return new Version(major, minor, patch + 1);
   }
-
-  /// 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 : VersionConstraint.empty;
     }
-
-    throw new ArgumentError(
-        'Unknown VersionConstraint type $other.');
+    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);
-
-    // Pre-releases always come before no pre-release string.
     if (!isPreRelease && other.isPreRelease) return 1;
     if (!other.isPreRelease && isPreRelease) return -1;
-
     var comparison = _compareLists(preRelease, other.preRelease);
     if (comparison != 0) return comparison;
-
-    // Builds always come after no build string.
     if (build.isEmpty && other.build.isNotEmpty) return -1;
     if (other.build.isEmpty && build.isNotEmpty) return 1;
     return _compareLists(build, other.build);
   }
-
   String toString() => _text;
-
-  /// Compares a dot-separated component of two versions.
-  ///
-  /// This is used for the pre-release and build version parts. This follows
-  /// Rule 12 of the Semantic Versioning spec (v2.0.0-rc.1).
   int _compareLists(List a, List b) {
     for (var i = 0; i < max(a.length, b.length); i++) {
       var aPart = (i < a.length) ? a[i] : null;
       var bPart = (i < b.length) ? b[i] : null;
-
       if (aPart == bPart) continue;
-
-      // Missing parts come before present ones.
       if (aPart == null) return -1;
       if (bPart == null) return 1;
-
       if (aPart is num) {
         if (bPart is num) {
-          // Compare two numbers.
           return aPart.compareTo(bPart);
         } else {
-          // Numbers come before strings.
           return -1;
         }
       } else {
         if (bPart is num) {
-          // Strings come after numbers.
           return 1;
         } else {
-          // Compare two strings.
           return aPart.compareTo(bPart);
         }
       }
     }
-
-    // The lists are entirely equal.
     return 0;
   }
 }
-
-/// 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.
   static VersionConstraint empty = const _EmptyVersion();
-
-  /// Parses a version constraint.
-  ///
-  /// This string is either "any" or a 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.
-  ///
-  /// Whitespace is ignored.
-  ///
-  /// Examples:
-  ///
-  ///     any
-  ///     1.2.3-alpha
-  ///     <=5.1.4
-  ///     >2.0.4 <= 2.4.6
   factory VersionConstraint.parse(String text) {
-    // Handle the "any" constraint.
     if (text.trim() == "any") return new VersionRange();
-
     var originalText = text;
     var constraints = <VersionConstraint>[];
-
     void skipWhitespace() {
       text = text.trim();
     }
-
-    // Try to parse and consume a version number.
     Version matchVersion() {
       var version = _START_VERSION.firstMatch(text);
       if (version == null) return null;
-
       text = text.substring(version.end);
       return new Version.parse(version[0]);
     }
-
-    // Try to parse and consume a comparison operator followed by a version.
     VersionConstraint matchComparison() {
       var comparison = _START_COMPARISON.firstMatch(text);
       if (comparison == null) return null;
-
       var op = comparison[0];
       text = text.substring(comparison.end);
       skipWhitespace();
-
       var version = matchVersion();
       if (version == null) {
-        throw new FormatException('Expected version number after "$op" in '
-            '"$originalText", got "$text".');
+        throw new FormatException(
+            'Expected version number after "$op" in ' '"$originalText", got "$text".');
       }
-
       switch (op) {
         case '<=':
           return new VersionRange(max: version, includeMax: true);
@@ -382,208 +198,141 @@ abstract class VersionConstraint {
       }
       throw "Unreachable.";
     }
-
     while (true) {
       skipWhitespace();
       if (text.isEmpty) break;
-
       var version = matchVersion();
       if (version != null) {
         constraints.add(version);
         continue;
       }
-
       var comparison = matchComparison();
       if (comparison != null) {
         constraints.add(comparison);
         continue;
       }
-
-      // If we got here, we couldn't parse the remaining string.
-      throw new FormatException('Could not parse version "$originalText". '
-          'Unknown text at "$text".');
+      throw new FormatException(
+          'Could not parse version "$originalText". ' 'Unknown text at "$text".');
     }
-
     if (constraints.isEmpty) {
       throw new FormatException('Cannot parse an empty string.');
     }
-
     return new VersionConstraint.intersection(constraints);
   }
-
-  /// Creates a new version constraint that is the intersection of
-  /// [constraints].
-  ///
-  /// It only allows versions that all of those constraints allow. If
-  /// constraints is empty, then it returns a VersionConstraint that allows
-  /// all versions.
-  factory VersionConstraint.intersection(
-      Iterable<VersionConstraint> constraints) {
+  factory
+      VersionConstraint.intersection(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;
-
-  /// Returns `true` if this constraint allows all versions.
   bool get isAny;
-
-  /// 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);
 }
-
-/// 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;
   final Version max;
   final bool includeMin;
   final bool includeMax;
-
-  VersionRange({this.min, this.max,
-      this.includeMin: false, this.includeMax: false}) {
+  VersionRange({this.min, this.max, this.includeMin: false, this.includeMax:
+      false}) {
     if (min != null && max != null && min > max) {
       throw new ArgumentError(
           'Minimum version ("$min") must be less than maximum ("$max").');
     }
   }
-
   bool operator ==(other) {
     if (other is! VersionRange) return false;
-
     return min == other.min &&
-           max == other.max &&
-           includeMin == other.includeMin &&
-           includeMax == other.includeMax;
+        max == other.max &&
+        includeMin == other.includeMin &&
+        includeMax == other.includeMax;
   }
-
   bool get isEmpty => false;
-
   bool get isAny => min == null && max == null;
-
-  /// Tests if [other] matches falls within this version range.
   bool allows(Version other) {
     if (min != null) {
       if (other < min) return false;
       if (!includeMin && other == min) return false;
     }
-
     if (max != null) {
       if (other > max) return false;
       if (!includeMax && other == max) return false;
-
-      // If the max isn't itself a pre-release, don't allow any pre-release
-      // versions of the max.
-      //
-      // See: https://www.npmjs.org/doc/misc/semver.html
       if (!includeMax &&
-          !max.isPreRelease && other.isPreRelease &&
-          other.major == max.major && other.minor == max.minor &&
+          !max.isPreRelease &&
+          other.isPreRelease &&
+          other.major == max.major &&
+          other.minor == max.minor &&
           other.patch == max.patch) {
         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 : 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.
-      } else if (intersectMin == null || intersectMin < other.min) {
+      if (other.min ==
+          null) {} else if (intersectMin == null || intersectMin < other.min) {
         intersectMin = other.min;
         intersectIncludeMin = other.includeMin;
       } else if (intersectMin == other.min && !other.includeMin) {
-        // The edges are the same, but one is exclusive, make it exclusive.
         intersectIncludeMin = false;
       }
-
-      if (other.max == null) {
-        // Do nothing.
-      } else if (intersectMax == null || intersectMax > other.max) {
+      if (other.max ==
+          null) {} else if (intersectMax == null || intersectMax > other.max) {
         intersectMax = other.max;
         intersectIncludeMax = other.includeMax;
       } else if (intersectMax == other.max && !other.includeMax) {
-        // The edges are the same, but one is exclusive, make it exclusive.
         intersectIncludeMax = false;
       }
-
       if (intersectMin == null && intersectMax == null) {
-        // 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 VersionConstraint.empty;
       }
-
-      if (intersectMin != null && intersectMax != null &&
+      if (intersectMin != null &&
+          intersectMax != null &&
           intersectMin > intersectMax) {
-        // Non-overlapping ranges, so empty.
         return VersionConstraint.empty;
       }
-
-      // If we got here, there is an actual range.
-      return new VersionRange(min: intersectMin, max: intersectMax,
-          includeMin: intersectIncludeMin, includeMax: intersectIncludeMax);
+      return new VersionRange(
+          min: intersectMin,
+          max: intersectMax,
+          includeMin: intersectIncludeMin,
+          includeMax: intersectIncludeMax);
     }
-
-    throw new ArgumentError(
-        'Unknown VersionConstraint type $other.');
+    throw new ArgumentError('Unknown VersionConstraint type $other.');
   }
-
   String toString() {
     var buffer = new StringBuffer();
-
     if (min != null) {
       buffer.write(includeMin ? '>=' : '>');
       buffer.write(min);
     }
-
     if (max != null) {
       if (min != null) buffer.write(' ');
       buffer.write(includeMax ? '<=' : '<');
       buffer.write(max);
     }
-
     if (min == null && max == null) buffer.write('any');
     return buffer.toString();
   }
 }
-
 class _EmptyVersion implements VersionConstraint {
   const _EmptyVersion();
-
   bool get isEmpty => true;
   bool get isAny => false;
   bool allows(Version other) => false;