diff --git a/pkgs/pub_semver/.travis.yml b/pkgs/pub_semver/.travis.yml
index c654072..0e732d0 100644
--- a/pkgs/pub_semver/.travis.yml
+++ b/pkgs/pub_semver/.travis.yml
@@ -1,13 +1,23 @@
 language: dart
-sudo: false
+
 dart:
   - dev
-  - stable
+  - 2.0.0
 
 dart_task:
   - test
-  - dartfmt
-  - dartanalyzer
+
+matrix:
+  include:
+    # Only validate formatting using the dev release
+    - dart: dev
+      dart_task: dartfmt
+    - dart: dev
+      dart_task:
+        dartanalyzer: --fatal-warnings --fatal-hints .
+    - dart: 2.0.0
+      dart_task:
+        dartanalyzer: --fatal-warnings .
 
 # Only building master means that we don't run two builds for each pull request.
 branches:
diff --git a/pkgs/pub_semver/CHANGELOG.md b/pkgs/pub_semver/CHANGELOG.md
index f8feb24..4183252 100644
--- a/pkgs/pub_semver/CHANGELOG.md
+++ b/pkgs/pub_semver/CHANGELOG.md
@@ -1,3 +1,8 @@
+# 1.4.3
+
+- Update Dart SDK constraint to `>=2.0.0 <3.0.0`.
+- Update `package:collection` constraint to `^1.0.0`.
+
 # 1.4.2
 
 * Set max SDK version to `<3.0.0`.
diff --git a/pkgs/pub_semver/analysis_options.yaml b/pkgs/pub_semver/analysis_options.yaml
new file mode 100644
index 0000000..c970ea7
--- /dev/null
+++ b/pkgs/pub_semver/analysis_options.yaml
@@ -0,0 +1,93 @@
+include: package:pedantic/analysis_options.yaml
+analyzer:
+#  strong-mode:
+#    implicit-casts: false
+linter:
+  rules:
+    - always_declare_return_types
+    #- annotate_overrides
+    - avoid_bool_literals_in_conditional_expressions
+    - avoid_classes_with_only_static_members
+    - avoid_empty_else
+    - avoid_function_literals_in_foreach_calls
+    - avoid_init_to_null
+    - avoid_null_checks_in_equality_operators
+    - avoid_relative_lib_imports
+    - avoid_renaming_method_parameters
+    - avoid_return_types_on_setters
+    - avoid_returning_null
+    - avoid_returning_null_for_future
+    - avoid_returning_null_for_void
+    - avoid_returning_this
+    - avoid_shadowing_type_parameters
+    - avoid_single_cascade_in_expression_statements
+    - avoid_types_as_parameter_names
+    - avoid_unused_constructor_parameters
+    - await_only_futures
+    - camel_case_types
+    - cancel_subscriptions
+    - cascade_invocations
+    - comment_references
+    - constant_identifier_names
+    - control_flow_in_finally
+    - directives_ordering
+    - empty_catches
+    - empty_constructor_bodies
+    - empty_statements
+    - file_names
+    - hash_and_equals
+    - implementation_imports
+    - invariant_booleans
+    - iterable_contains_unrelated_type
+    - join_return_with_assignment
+    - library_names
+    - library_prefixes
+    - list_remove_unrelated_type
+    - literal_only_boolean_expressions
+    - no_adjacent_strings_in_list
+    - no_duplicate_case_values
+    - non_constant_identifier_names
+    - null_closures
+    - omit_local_variable_types
+    - only_throw_errors
+    - overridden_fields
+    - package_api_docs
+    - package_names
+    - package_prefixed_library_names
+    - prefer_adjacent_string_concatenation
+    - prefer_collection_literals
+    - prefer_conditional_assignment
+    - prefer_const_constructors
+    - prefer_contains
+    - prefer_equal_for_default_values
+    - prefer_final_fields
+    #- prefer_final_locals
+    - prefer_generic_function_type_aliases
+    - prefer_initializing_formals
+    - prefer_interpolation_to_compose_strings
+    - prefer_is_empty
+    - prefer_is_not_empty
+    - prefer_null_aware_operators
+    #- prefer_single_quotes
+    - prefer_typing_uninitialized_variables
+    - recursive_getters
+    - slash_for_doc_comments
+    - test_types_in_equals
+    - throw_in_finally
+    - type_init_formals
+    - unawaited_futures
+    - unnecessary_await_in_return
+    - unnecessary_brace_in_string_interps
+    - unnecessary_const
+    - unnecessary_getters_setters
+    - unnecessary_lambdas
+    - unnecessary_new
+    - unnecessary_null_aware_assignments
+    - unnecessary_parenthesis
+    - unnecessary_statements
+    - unnecessary_this
+    - unrelated_type_equality_checks
+    - use_function_type_syntax_for_parameters
+    - use_rethrow_when_possible
+    - valid_regexps
+    - void_checks
diff --git a/pkgs/pub_semver/lib/src/patterns.dart b/pkgs/pub_semver/lib/src/patterns.dart
index c4d75d4..8829447 100644
--- a/pkgs/pub_semver/lib/src/patterns.dart
+++ b/pkgs/pub_semver/lib/src/patterns.dart
@@ -3,17 +3,17 @@
 // BSD-style license that can be found in the LICENSE file.
 
 /// Regex that matches a version number at the beginning of a string.
-final START_VERSION = new RegExp(r'^' // Start at beginning.
+final startVersion = 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.
-final COMPLETE_VERSION = new RegExp(START_VERSION.pattern + r'$');
+/// Like [startVersion] but matches the entire string.
+final completeVersion = RegExp('${startVersion.pattern}\$');
 
 /// Parses a comparison operator ("<", ">", "<=", or ">=") at the beginning of
 /// a string.
-final START_COMPARISON = new RegExp(r"^[<>]=?");
+final startComparison = RegExp(r"^[<>]=?");
 
 /// The "compatible with" operator.
-const COMPATIBLE_WITH = "^";
+const compatibleWithChar = "^";
diff --git a/pkgs/pub_semver/lib/src/version.dart b/pkgs/pub_semver/lib/src/version.dart
index 19ae962..031af52 100644
--- a/pkgs/pub_semver/lib/src/version.dart
+++ b/pkgs/pub_semver/lib/src/version.dart
@@ -16,7 +16,7 @@
 /// A parsed semantic version number.
 class Version implements VersionConstraint, VersionRange {
   /// No released version: i.e. "0.0.0".
-  static Version get none => new Version(0, 0, 0);
+  static Version get none => Version(0, 0, 0);
 
   /// Compares [a] and [b] to see which takes priority over the other.
   ///
@@ -92,12 +92,9 @@
       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 ArgumentError('Major version must be non-negative.');
+    if (minor < 0) throw ArgumentError('Minor version must be non-negative.');
+    if (patch < 0) throw ArgumentError('Patch version must be non-negative.');
   }
 
   /// Creates a new [Version] object.
@@ -106,27 +103,27 @@
     if (pre != null) text += "-$pre";
     if (build != null) text += "+$build";
 
-    return new Version._(major, minor, patch, pre, build, text);
+    return 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);
+    final match = completeVersion.firstMatch(text);
     if (match == null) {
-      throw new FormatException('Could not parse "$text".');
+      throw FormatException('Could not parse "$text".');
     }
 
     try {
-      int major = int.parse(match[1]);
-      int minor = int.parse(match[2]);
-      int patch = int.parse(match[3]);
+      var major = int.parse(match[1]);
+      var minor = int.parse(match[2]);
+      var patch = int.parse(match[3]);
 
-      String preRelease = match[5];
-      String build = match[8];
+      var preRelease = match[5];
+      var build = match[8];
 
-      return new Version._(major, minor, patch, preRelease, build, text);
+      return Version._(major, minor, patch, preRelease, build, text);
     } on FormatException {
-      throw new FormatException('Could not parse "$text".');
+      throw FormatException('Could not parse "$text".');
     }
   }
 
@@ -135,7 +132,7 @@
   /// 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;
+    Version primary;
     for (var version in versions) {
       if (primary == null ||
           (!version.isPreRelease && primary.isPreRelease) ||
@@ -195,7 +192,7 @@
   /// and patch.
   Version get nextMajor {
     if (isPreRelease && minor == 0 && patch == 0) {
-      return new Version(major, minor, patch);
+      return Version(major, minor, patch);
     }
 
     return _incrementMajor();
@@ -208,7 +205,7 @@
   /// Otherwise, it increments the minor version and resets the patch.
   Version get nextMinor {
     if (isPreRelease && patch == 0) {
-      return new Version(major, minor, patch);
+      return Version(major, minor, patch);
     }
 
     return _incrementMinor();
@@ -220,7 +217,7 @@
   /// suffix. Otherwise, it increments the patch version.
   Version get nextPatch {
     if (isPreRelease) {
-      return new Version(major, minor, patch);
+      return Version(major, minor, patch);
     }
 
     return _incrementPatch();
@@ -240,14 +237,14 @@
   }
 
   /// Returns the first possible pre-release of this version.
-  Version get firstPreRelease => new Version(major, minor, patch, pre: "0");
+  Version get firstPreRelease => Version(major, minor, patch, pre: "0");
 
   /// Returns whether this is the first possible pre-release of its version.
   bool get isFirstPreRelease => preRelease.length == 1 && preRelease.first == 0;
 
-  Version _incrementMajor() => new Version(major + 1, 0, 0);
-  Version _incrementMinor() => new Version(major, minor + 1, 0);
-  Version _incrementPatch() => new Version(major, minor, patch + 1);
+  Version _incrementMajor() => Version(major + 1, 0, 0);
+  Version _incrementMinor() => Version(major, minor + 1, 0);
+  Version _incrementPatch() => Version(major, minor, patch + 1);
 
   /// Tests if [other] matches this version exactly.
   bool allows(Version other) => this == other;
@@ -264,7 +261,7 @@
 
     if (other is VersionRange) {
       if (other.min == this) {
-        return new VersionRange(
+        return VersionRange(
             min: other.min,
             max: other.max,
             includeMin: true,
@@ -273,7 +270,7 @@
       }
 
       if (other.max == this) {
-        return new VersionRange(
+        return VersionRange(
             min: other.min,
             max: other.max,
             includeMin: other.includeMin,
@@ -282,7 +279,7 @@
       }
     }
 
-    return new VersionConstraint.unionOf([this, other]);
+    return VersionConstraint.unionOf([this, other]);
   }
 
   VersionConstraint difference(VersionConstraint other) =>
diff --git a/pkgs/pub_semver/lib/src/version_constraint.dart b/pkgs/pub_semver/lib/src/version_constraint.dart
index 67093f7..6dfd396 100644
--- a/pkgs/pub_semver/lib/src/version_constraint.dart
+++ b/pkgs/pub_semver/lib/src/version_constraint.dart
@@ -16,7 +16,7 @@
 /// version.
 abstract class VersionConstraint {
   /// A [VersionConstraint] that allows all versions.
-  static VersionConstraint any = new VersionRange();
+  static VersionConstraint any = VersionRange();
 
   /// A [VersionConstraint] that allows no versions -- the empty set.
   static VersionConstraint empty = const _EmptyVersion();
@@ -47,7 +47,7 @@
   factory VersionConstraint.parse(String text) {
     var originalText = text;
 
-    skipWhitespace() {
+    void skipWhitespace() {
       text = text.trim();
     }
 
@@ -58,16 +58,16 @@
 
     // Try to parse and consume a version number.
     Version matchVersion() {
-      var version = START_VERSION.firstMatch(text);
+      var version = startVersion.firstMatch(text);
       if (version == null) return null;
 
       text = text.substring(version.end);
-      return new Version.parse(version[0]);
+      return Version.parse(version[0]);
     }
 
     // Try to parse and consume a comparison operator followed by a version.
     VersionRange matchComparison() {
-      var comparison = START_COMPARISON.firstMatch(text);
+      var comparison = startComparison.firstMatch(text);
       if (comparison == null) return null;
 
       var op = comparison[0];
@@ -76,45 +76,45 @@
 
       var version = matchVersion();
       if (version == null) {
-        throw new FormatException('Expected version number after "$op" in '
+        throw FormatException('Expected version number after "$op" in '
             '"$originalText", got "$text".');
       }
 
       switch (op) {
         case '<=':
-          return new VersionRange(max: version, includeMax: true);
+          return VersionRange(max: version, includeMax: true);
         case '<':
-          return new VersionRange(
+          return VersionRange(
               max: version,
               includeMax: false,
               alwaysIncludeMaxPreRelease: true);
         case '>=':
-          return new VersionRange(min: version, includeMin: true);
+          return VersionRange(min: version, includeMin: true);
         case '>':
-          return new VersionRange(min: version, includeMin: false);
+          return VersionRange(min: version, includeMin: false);
       }
-      throw "Unreachable.";
+      throw FallThroughError();
     }
 
     // Try to parse the "^" operator followed by a version.
-    matchCompatibleWith() {
-      if (!text.startsWith(COMPATIBLE_WITH)) return null;
+    VersionConstraint matchCompatibleWith() {
+      if (!text.startsWith(compatibleWithChar)) return null;
 
-      text = text.substring(COMPATIBLE_WITH.length);
+      text = text.substring(compatibleWithChar.length);
       skipWhitespace();
 
       var version = matchVersion();
       if (version == null) {
-        throw new FormatException('Expected version number after '
-            '"$COMPATIBLE_WITH" in "$originalText", got "$text".');
+        throw FormatException('Expected version number after '
+            '"$compatibleWithChar" in "$originalText", got "$text".');
       }
 
       if (text.isNotEmpty) {
-        throw new FormatException('Cannot include other constraints with '
-            '"$COMPATIBLE_WITH" constraint in "$originalText".');
+        throw FormatException('Cannot include other constraints with '
+            '"$compatibleWithChar" constraint in "$originalText".');
       }
 
-      return new VersionConstraint.compatibleWith(version);
+      return VersionConstraint.compatibleWith(version);
     }
 
     var compatibleWith = matchCompatibleWith();
@@ -125,14 +125,14 @@
     Version max;
     var includeMax = false;
 
-    while (true) {
+    for (;;) {
       skipWhitespace();
 
       if (text.isEmpty) break;
 
       var newRange = matchVersion() ?? matchComparison();
       if (newRange == null) {
-        throw new FormatException('Could not parse version "$originalText". '
+        throw FormatException('Could not parse version "$originalText". '
             'Unknown text at "$text".');
       }
 
@@ -156,7 +156,7 @@
     }
 
     if (min == null && max == null) {
-      throw new FormatException('Cannot parse an empty string.');
+      throw const FormatException('Cannot parse an empty string.');
     }
 
     if (min != null && max != null) {
@@ -167,7 +167,7 @@
       }
     }
 
-    return new VersionRange(
+    return VersionRange(
         min: min, includeMin: includeMin, max: max, includeMax: includeMax);
   }
 
@@ -178,7 +178,7 @@
   /// are greater than or equal to [version], but less than the next breaking
   /// version ([Version.nextBreaking]) of [version].
   factory VersionConstraint.compatibleWith(Version version) =>
-      new CompatibleWithVersionRange(version);
+      CompatibleWithVersionRange(version);
 
   /// Creates a new version constraint that is the intersection of
   /// [constraints].
@@ -188,7 +188,7 @@
   /// all versions.
   factory VersionConstraint.intersection(
       Iterable<VersionConstraint> constraints) {
-    var constraint = new VersionRange();
+    var constraint = VersionRange();
     for (var other in constraints) {
       constraint = constraint.intersect(other);
     }
@@ -217,7 +217,7 @@
     // filtered out above.
     for (var constraint in flattened) {
       if (constraint is VersionRange) continue;
-      throw new ArgumentError('Unknown VersionConstraint type $constraint.');
+      throw ArgumentError('Unknown VersionConstraint type $constraint.');
     }
 
     flattened.sort();
@@ -235,7 +235,7 @@
     }
 
     if (merged.length == 1) return merged.single;
-    return new VersionUnion.fromRanges(merged);
+    return VersionUnion.fromRanges(merged);
   }
 
   /// Returns `true` if this constraint allows no versions.
@@ -259,7 +259,7 @@
   /// this and [other].
   VersionConstraint intersect(VersionConstraint other);
 
-  /// Returns a [VersionConstraint] that allows [Versions]s allowed by either
+  /// Returns a [VersionConstraint] that allows [Version]s allowed by either
   /// this or [other].
   VersionConstraint union(VersionConstraint other);
 
@@ -272,12 +272,20 @@
   const _EmptyVersion();
 
   bool get isEmpty => true;
+
   bool get isAny => false;
+
   bool allows(Version other) => false;
+
   bool allowsAll(VersionConstraint other) => other.isEmpty;
+
   bool allowsAny(VersionConstraint other) => false;
+
   VersionConstraint intersect(VersionConstraint other) => this;
+
   VersionConstraint union(VersionConstraint other) => other;
+
   VersionConstraint difference(VersionConstraint other) => this;
+
   String toString() => '<empty>';
 }
diff --git a/pkgs/pub_semver/lib/src/version_range.dart b/pkgs/pub_semver/lib/src/version_range.dart
index a566891..8ac79da 100644
--- a/pkgs/pub_semver/lib/src/version_range.dart
+++ b/pkgs/pub_semver/lib/src/version_range.dart
@@ -60,11 +60,11 @@
   factory VersionRange(
       {Version min,
       Version max,
-      bool includeMin: false,
-      bool includeMax: false,
-      bool alwaysIncludeMaxPreRelease: false}) {
+      bool includeMin = false,
+      bool includeMax = false,
+      bool alwaysIncludeMaxPreRelease = false}) {
     if (min != null && max != null && min > max) {
-      throw new ArgumentError(
+      throw ArgumentError(
           'Minimum version ("$min") must be less than maximum ("$max").');
     }
 
@@ -79,7 +79,7 @@
       max = max.firstPreRelease;
     }
 
-    return new VersionRange._(min, max, includeMin, includeMax);
+    return VersionRange._(min, max, includeMin, includeMax);
   }
 
   VersionRange._(this.min, this.max, this.includeMin, this.includeMax);
@@ -123,14 +123,14 @@
     if (other is Version) return allows(other);
 
     if (other is VersionUnion) {
-      return other.ranges.every((constraint) => allowsAll(constraint));
+      return other.ranges.every(allowsAll);
     }
 
     if (other is VersionRange) {
       return !allowsLower(other, this) && !allowsHigher(other, this);
     }
 
-    throw new ArgumentError('Unknown VersionConstraint type $other.');
+    throw ArgumentError('Unknown VersionConstraint type $other.');
   }
 
   bool allowsAny(VersionConstraint other) {
@@ -138,14 +138,14 @@
     if (other is Version) return allows(other);
 
     if (other is VersionUnion) {
-      return other.ranges.any((constraint) => allowsAny(constraint));
+      return other.ranges.any(allowsAny);
     }
 
     if (other is VersionRange) {
       return !strictlyLower(other, this) && !strictlyHigher(other, this);
     }
 
-    throw new ArgumentError('Unknown VersionConstraint type $other.');
+    throw ArgumentError('Unknown VersionConstraint type $other.');
   }
 
   VersionConstraint intersect(VersionConstraint other) {
@@ -167,8 +167,8 @@
         intersectIncludeMin = other.includeMin;
       } else {
         if (strictlyLower(other, this)) return VersionConstraint.empty;
-        intersectMin = this.min;
-        intersectIncludeMin = this.includeMin;
+        intersectMin = min;
+        intersectIncludeMin = includeMin;
       }
 
       Version intersectMax;
@@ -177,13 +177,13 @@
         intersectMax = other.max;
         intersectIncludeMax = other.includeMax;
       } else {
-        intersectMax = this.max;
-        intersectIncludeMax = this.includeMax;
+        intersectMax = max;
+        intersectIncludeMax = includeMax;
       }
 
       if (intersectMin == null && intersectMax == null) {
         // Open range.
-        return new VersionRange();
+        return VersionRange();
       }
 
       // If the range is just a single version.
@@ -195,7 +195,7 @@
       }
 
       // If we got here, there is an actual range.
-      return new VersionRange(
+      return VersionRange(
           min: intersectMin,
           max: intersectMax,
           includeMin: intersectIncludeMin,
@@ -203,7 +203,7 @@
           alwaysIncludeMaxPreRelease: true);
     }
 
-    throw new ArgumentError('Unknown VersionConstraint type $other.');
+    throw ArgumentError('Unknown VersionConstraint type $other.');
   }
 
   VersionConstraint union(VersionConstraint other) {
@@ -211,24 +211,24 @@
       if (allows(other)) return this;
 
       if (other == min) {
-        return new VersionRange(
-            min: this.min,
-            max: this.max,
+        return VersionRange(
+            min: min,
+            max: max,
             includeMin: true,
-            includeMax: this.includeMax,
+            includeMax: includeMax,
             alwaysIncludeMaxPreRelease: true);
       }
 
       if (other == max) {
-        return new VersionRange(
-            min: this.min,
-            max: this.max,
-            includeMin: this.includeMin,
+        return VersionRange(
+            min: min,
+            max: max,
+            includeMin: includeMin,
             includeMax: true,
             alwaysIncludeMaxPreRelease: true);
       }
 
-      return new VersionConstraint.unionOf([this, other]);
+      return VersionConstraint.unionOf([this, other]);
     }
 
     if (other is VersionRange) {
@@ -237,14 +237,14 @@
       var edgesTouch = (max == other.min && (includeMax || other.includeMin)) ||
           (min == other.max && (includeMin || other.includeMax));
       if (!edgesTouch && !allowsAny(other)) {
-        return new VersionConstraint.unionOf([this, other]);
+        return VersionConstraint.unionOf([this, other]);
       }
 
       Version unionMin;
       bool unionIncludeMin;
       if (allowsLower(this, other)) {
-        unionMin = this.min;
-        unionIncludeMin = this.includeMin;
+        unionMin = min;
+        unionIncludeMin = includeMin;
       } else {
         unionMin = other.min;
         unionIncludeMin = other.includeMin;
@@ -253,14 +253,14 @@
       Version unionMax;
       bool unionIncludeMax;
       if (allowsHigher(this, other)) {
-        unionMax = this.max;
-        unionIncludeMax = this.includeMax;
+        unionMax = max;
+        unionIncludeMax = includeMax;
       } else {
         unionMax = other.max;
         unionIncludeMax = other.includeMax;
       }
 
-      return new VersionRange(
+      return VersionRange(
           min: unionMin,
           max: unionMax,
           includeMin: unionIncludeMin,
@@ -268,7 +268,7 @@
           alwaysIncludeMaxPreRelease: true);
     }
 
-    return new VersionConstraint.unionOf([this, other]);
+    return VersionConstraint.unionOf([this, other]);
   }
 
   VersionConstraint difference(VersionConstraint other) {
@@ -279,7 +279,7 @@
 
       if (other == min) {
         if (!includeMin) return this;
-        return new VersionRange(
+        return VersionRange(
             min: min,
             max: max,
             includeMin: false,
@@ -289,7 +289,7 @@
 
       if (other == max) {
         if (!includeMax) return this;
-        return new VersionRange(
+        return VersionRange(
             min: min,
             max: max,
             includeMin: includeMin,
@@ -297,14 +297,14 @@
             alwaysIncludeMaxPreRelease: true);
       }
 
-      return new VersionUnion.fromRanges([
-        new VersionRange(
+      return VersionUnion.fromRanges([
+        VersionRange(
             min: min,
             max: other,
             includeMin: includeMin,
             includeMax: false,
             alwaysIncludeMaxPreRelease: true),
-        new VersionRange(
+        VersionRange(
             min: other,
             max: max,
             includeMin: false,
@@ -322,7 +322,7 @@
         assert(min != null);
         before = min;
       } else {
-        before = new VersionRange(
+        before = VersionRange(
             min: min,
             max: other.min,
             includeMin: includeMin,
@@ -338,7 +338,7 @@
         assert(max != null);
         after = max;
       } else {
-        after = new VersionRange(
+        after = VersionRange(
             min: other.max,
             max: max,
             includeMin: !other.includeMax,
@@ -349,7 +349,7 @@
       if (before == null && after == null) return VersionConstraint.empty;
       if (before == null) return after;
       if (after == null) return before;
-      return new VersionUnion.fromRanges([before, after]);
+      return VersionUnion.fromRanges([before, after]);
     } else if (other is VersionUnion) {
       var ranges = <VersionRange>[];
       var current = this;
@@ -377,10 +377,10 @@
       }
 
       if (ranges.isEmpty) return current;
-      return new VersionUnion.fromRanges(ranges..add(current));
+      return VersionUnion.fromRanges(ranges..add(current));
     }
 
-    throw new ArgumentError('Unknown VersionConstraint type $other.');
+    throw ArgumentError('Unknown VersionConstraint type $other.');
   }
 
   int compareTo(VersionRange other) {
@@ -398,7 +398,7 @@
     return _compareMax(other);
   }
 
-  /// Compares the maximum values of [this] and [other].
+  /// Compares the maximum values of `this` and [other].
   int _compareMax(VersionRange other) {
     if (max == null) {
       if (other.max == null) return 0;
@@ -414,18 +414,16 @@
   }
 
   String toString() {
-    var buffer = new StringBuffer();
+    var buffer = StringBuffer();
 
     if (min != null) {
-      buffer.write(includeMin ? '>=' : '>');
-      buffer.write(min);
+      buffer..write(includeMin ? '>=' : '>')..write(min);
     }
 
     if (max != null) {
       if (min != null) buffer.write(' ');
       if (includeMax) {
-        buffer.write('<=');
-        buffer.write(max);
+        buffer..write('<=')..write(max);
       } else {
         buffer.write('<');
         if (max.isFirstPreRelease) {
diff --git a/pkgs/pub_semver/lib/src/version_union.dart b/pkgs/pub_semver/lib/src/version_union.dart
index 9324d3f..b774163 100644
--- a/pkgs/pub_semver/lib/src/version_union.dart
+++ b/pkgs/pub_semver/lib/src/version_union.dart
@@ -113,7 +113,7 @@
     if (newRanges.isEmpty) return VersionConstraint.empty;
     if (newRanges.length == 1) return newRanges.single;
 
-    return new VersionUnion.fromRanges(newRanges);
+    return VersionUnion.fromRanges(newRanges);
   }
 
   VersionConstraint difference(VersionConstraint other) {
@@ -125,7 +125,7 @@
     theirRanges.moveNext();
     var current = ourRanges.current;
 
-    theirNextRange() {
+    bool theirNextRange() {
       if (theirRanges.moveNext()) return true;
 
       // If there are no more of their ranges, none of the rest of our ranges
@@ -137,14 +137,14 @@
       return false;
     }
 
-    ourNextRange({bool includeCurrent: true}) {
+    bool ourNextRange({bool includeCurrent = true}) {
       if (includeCurrent) newRanges.add(current);
       if (!ourRanges.moveNext()) return false;
       current = ourRanges.current;
       return true;
     }
 
-    while (true) {
+    for (;;) {
       // If the current ranges are disjoint, move the lowest one forward.
       if (strictlyLower(theirRanges.current, current)) {
         if (!theirNextRange()) break;
@@ -187,7 +187,7 @@
 
     if (newRanges.isEmpty) return VersionConstraint.empty;
     if (newRanges.length == 1) return newRanges.single;
-    return new VersionUnion.fromRanges(newRanges);
+    return VersionUnion.fromRanges(newRanges);
   }
 
   /// Returns [constraint] as a list of ranges.
@@ -197,11 +197,11 @@
     if (constraint.isEmpty) return [];
     if (constraint is VersionUnion) return constraint.ranges;
     if (constraint is VersionRange) return [constraint];
-    throw new ArgumentError('Unknown VersionConstraint type $constraint.');
+    throw ArgumentError('Unknown VersionConstraint type $constraint.');
   }
 
   VersionConstraint union(VersionConstraint other) =>
-      new VersionConstraint.unionOf([this, other]);
+      VersionConstraint.unionOf([this, other]);
 
   bool operator ==(other) {
     if (other is! VersionUnion) return false;
diff --git a/pkgs/pub_semver/pubspec.yaml b/pkgs/pub_semver/pubspec.yaml
index 56fa52b..b92d2f6 100644
--- a/pkgs/pub_semver/pubspec.yaml
+++ b/pkgs/pub_semver/pubspec.yaml
@@ -1,17 +1,17 @@
 name: pub_semver
-version: 1.4.2
+version: 1.4.3-dev
 
-description: >
+description: >-
  Versions and version constraints implementing pub's versioning policy. This
  is very similar to vanilla semver, with a few corner cases.
 author: Dart Team <misc@dartlang.org>
 homepage: http://github.com/dart-lang/pub_semver
 
 environment:
- sdk: '>=1.0.0 <3.0.0'
+ sdk: '>=2.0.0 <3.0.0'
 
 dependencies:
-  collection: '>=0.9.0 <2.0.0'
+  collection: ^1.0.0
 
 dev_dependencies:
-  test: '>=0.12.0 <2.0.0'
+  test: ^1.0.0
diff --git a/pkgs/pub_semver/test/utils.dart b/pkgs/pub_semver/test/utils.dart
index 8ecd8f5..a0fd684 100644
--- a/pkgs/pub_semver/test/utils.dart
+++ b/pkgs/pub_semver/test/utils.dart
@@ -7,24 +7,24 @@
 import 'package:pub_semver/pub_semver.dart';
 
 /// Some stock example versions to use in tests.
-final v003 = new Version.parse('0.0.3');
-final v010 = new Version.parse('0.1.0');
-final v072 = new Version.parse('0.7.2');
-final v080 = new Version.parse('0.8.0');
-final v114 = new Version.parse('1.1.4');
-final v123 = new Version.parse('1.2.3');
-final v124 = new Version.parse('1.2.4');
-final v130 = new Version.parse('1.3.0');
-final v140 = new Version.parse('1.4.0');
-final v200 = new Version.parse('2.0.0');
-final v201 = new Version.parse('2.0.1');
-final v234 = new Version.parse('2.3.4');
-final v250 = new Version.parse('2.5.0');
-final v300 = new Version.parse('3.0.0');
+final v003 = Version.parse('0.0.3');
+final v010 = Version.parse('0.1.0');
+final v072 = Version.parse('0.7.2');
+final v080 = Version.parse('0.8.0');
+final v114 = Version.parse('1.1.4');
+final v123 = Version.parse('1.2.3');
+final v124 = Version.parse('1.2.4');
+final v130 = Version.parse('1.3.0');
+final v140 = Version.parse('1.4.0');
+final v200 = Version.parse('2.0.0');
+final v201 = Version.parse('2.0.1');
+final v234 = Version.parse('2.3.4');
+final v250 = Version.parse('2.5.0');
+final v300 = Version.parse('3.0.0');
 
 /// A range that allows pre-release versions of its max version.
 final includeMaxPreReleaseRange =
-    new VersionRange(max: v200, alwaysIncludeMaxPreRelease: true);
+    VersionRange(max: v200, alwaysIncludeMaxPreRelease: true);
 
 /// A [Matcher] that tests if a [VersionConstraint] allows or does not allow a
 /// given list of [Version]s.
@@ -84,7 +84,7 @@
     Version v7,
     Version v8]) {
   var versions = _makeVersionList(v1, v2, v3, v4, v5, v6, v7, v8);
-  return new _VersionConstraintMatcher(versions, true);
+  return _VersionConstraintMatcher(versions, true);
 }
 
 /// Gets a [Matcher] that validates that a [VersionConstraint] allows none of
@@ -98,7 +98,7 @@
     Version v7,
     Version v8]) {
   var versions = _makeVersionList(v1, v2, v3, v4, v5, v6, v7, v8);
-  return new _VersionConstraintMatcher(versions, false);
+  return _VersionConstraintMatcher(versions, false);
 }
 
 List<Version> _makeVersionList(Version v1,
diff --git a/pkgs/pub_semver/test/version_constraint_test.dart b/pkgs/pub_semver/test/version_constraint_test.dart
index bf3a018..1e48391 100644
--- a/pkgs/pub_semver/test/version_constraint_test.dart
+++ b/pkgs/pub_semver/test/version_constraint_test.dart
@@ -8,13 +8,13 @@
 
 import 'utils.dart';
 
-main() {
+void main() {
   test('any', () {
     expect(VersionConstraint.any.isAny, isTrue);
     expect(
         VersionConstraint.any,
-        allows(new Version.parse('0.0.0-blah'), new Version.parse('1.2.3'),
-            new Version.parse('12345.678.90')));
+        allows(Version.parse('0.0.0-blah'), Version.parse('1.2.3'),
+            Version.parse('12345.678.90')));
   });
 
   test('empty', () {
@@ -22,141 +22,132 @@
     expect(VersionConstraint.empty.isAny, isFalse);
     expect(
         VersionConstraint.empty,
-        doesNotAllow(new Version.parse('0.0.0-blah'),
-            new Version.parse('1.2.3'), new Version.parse('12345.678.90')));
+        doesNotAllow(Version.parse('0.0.0-blah'), Version.parse('1.2.3'),
+            Version.parse('12345.678.90')));
   });
 
   group('parse()', () {
     test('parses an exact version', () {
-      var constraint = new VersionConstraint.parse('1.2.3-alpha');
+      var constraint = VersionConstraint.parse('1.2.3-alpha');
 
       expect(constraint is Version, isTrue);
-      expect(constraint, equals(new Version(1, 2, 3, pre: 'alpha')));
+      expect(constraint, equals(Version(1, 2, 3, pre: 'alpha')));
     });
 
     test('parses "any"', () {
-      var constraint = new VersionConstraint.parse('any');
+      var constraint = VersionConstraint.parse('any');
 
       expect(constraint is VersionConstraint, isTrue);
       expect(
           constraint,
-          allows(new Version.parse('0.0.0'), new Version.parse('1.2.3'),
-              new Version.parse('12345.678.90')));
+          allows(Version.parse('0.0.0'), Version.parse('1.2.3'),
+              Version.parse('12345.678.90')));
     });
 
     test('parses a ">" minimum version', () {
-      var constraint = new VersionConstraint.parse('>1.2.3');
+      var constraint = VersionConstraint.parse('>1.2.3');
 
       expect(constraint,
-          allows(new Version.parse('1.2.3+foo'), new Version.parse('1.2.4')));
+          allows(Version.parse('1.2.3+foo'), Version.parse('1.2.4')));
       expect(
           constraint,
-          doesNotAllow(new Version.parse('1.2.1'),
-              new Version.parse('1.2.3-build'), new Version.parse('1.2.3')));
+          doesNotAllow(Version.parse('1.2.1'), Version.parse('1.2.3-build'),
+              Version.parse('1.2.3')));
     });
 
     test('parses a ">=" minimum version', () {
-      var constraint = new VersionConstraint.parse('>=1.2.3');
+      var constraint = VersionConstraint.parse('>=1.2.3');
 
       expect(
           constraint,
-          allows(new Version.parse('1.2.3'), new Version.parse('1.2.3+foo'),
-              new Version.parse('1.2.4')));
-      expect(
-          constraint,
-          doesNotAllow(
-              new Version.parse('1.2.1'), new Version.parse('1.2.3-build')));
+          allows(Version.parse('1.2.3'), Version.parse('1.2.3+foo'),
+              Version.parse('1.2.4')));
+      expect(constraint,
+          doesNotAllow(Version.parse('1.2.1'), Version.parse('1.2.3-build')));
     });
 
     test('parses a "<" maximum version', () {
-      var constraint = new VersionConstraint.parse('<1.2.3');
+      var constraint = VersionConstraint.parse('<1.2.3');
 
       expect(constraint,
-          allows(new Version.parse('1.2.1'), new Version.parse('1.2.2+foo')));
+          allows(Version.parse('1.2.1'), Version.parse('1.2.2+foo')));
       expect(
           constraint,
-          doesNotAllow(new Version.parse('1.2.3'),
-              new Version.parse('1.2.3+foo'), new Version.parse('1.2.4')));
+          doesNotAllow(Version.parse('1.2.3'), Version.parse('1.2.3+foo'),
+              Version.parse('1.2.4')));
     });
 
     test('parses a "<=" maximum version', () {
-      var constraint = new VersionConstraint.parse('<=1.2.3');
+      var constraint = VersionConstraint.parse('<=1.2.3');
 
       expect(
           constraint,
-          allows(new Version.parse('1.2.1'), new Version.parse('1.2.3-build'),
-              new Version.parse('1.2.3')));
-      expect(
-          constraint,
-          doesNotAllow(
-              new Version.parse('1.2.3+foo'), new Version.parse('1.2.4')));
+          allows(Version.parse('1.2.1'), Version.parse('1.2.3-build'),
+              Version.parse('1.2.3')));
+      expect(constraint,
+          doesNotAllow(Version.parse('1.2.3+foo'), Version.parse('1.2.4')));
     });
 
     test('parses a series of space-separated constraints', () {
-      var constraint = new VersionConstraint.parse('>1.0.0 >=1.2.3 <1.3.0');
+      var constraint = VersionConstraint.parse('>1.0.0 >=1.2.3 <1.3.0');
 
-      expect(constraint,
-          allows(new Version.parse('1.2.3'), new Version.parse('1.2.5')));
+      expect(
+          constraint, allows(Version.parse('1.2.3'), Version.parse('1.2.5')));
       expect(
           constraint,
-          doesNotAllow(new Version.parse('1.2.3-pre'),
-              new Version.parse('1.3.0'), new Version.parse('3.4.5')));
+          doesNotAllow(Version.parse('1.2.3-pre'), Version.parse('1.3.0'),
+              Version.parse('3.4.5')));
     });
 
     test('parses a pre-release-only constraint', () {
-      var constraint = new VersionConstraint.parse('>=1.0.0-dev.2 <1.0.0');
-      expect(
-          constraint,
-          allows(new Version.parse('1.0.0-dev.2'),
-              new Version.parse('1.0.0-dev.3')));
-      expect(
-          constraint,
-          doesNotAllow(
-              new Version.parse('1.0.0-dev.1'), new Version.parse('1.0.0')));
+      var constraint = VersionConstraint.parse('>=1.0.0-dev.2 <1.0.0');
+      expect(constraint,
+          allows(Version.parse('1.0.0-dev.2'), Version.parse('1.0.0-dev.3')));
+      expect(constraint,
+          doesNotAllow(Version.parse('1.0.0-dev.1'), Version.parse('1.0.0')));
     });
 
     test('ignores whitespace around comparison operators', () {
-      var constraint = new VersionConstraint.parse(' >1.0.0>=1.2.3 < 1.3.0');
+      var constraint = VersionConstraint.parse(' >1.0.0>=1.2.3 < 1.3.0');
 
-      expect(constraint,
-          allows(new Version.parse('1.2.3'), new Version.parse('1.2.5')));
+      expect(
+          constraint, allows(Version.parse('1.2.3'), Version.parse('1.2.5')));
       expect(
           constraint,
-          doesNotAllow(new Version.parse('1.2.3-pre'),
-              new Version.parse('1.3.0'), new Version.parse('3.4.5')));
+          doesNotAllow(Version.parse('1.2.3-pre'), Version.parse('1.3.0'),
+              Version.parse('3.4.5')));
     });
 
     test('does not allow "any" to be mixed with other constraints', () {
-      expect(() => new VersionConstraint.parse('any 1.0.0'),
-          throwsFormatException);
+      expect(() => VersionConstraint.parse('any 1.0.0'), throwsFormatException);
     });
 
     test('parses a "^" version', () {
-      expect(new VersionConstraint.parse('^0.0.3'),
-          equals(new VersionConstraint.compatibleWith(v003)));
+      expect(VersionConstraint.parse('^0.0.3'),
+          equals(VersionConstraint.compatibleWith(v003)));
 
-      expect(new VersionConstraint.parse('^0.7.2'),
-          equals(new VersionConstraint.compatibleWith(v072)));
+      expect(VersionConstraint.parse('^0.7.2'),
+          equals(VersionConstraint.compatibleWith(v072)));
 
-      expect(new VersionConstraint.parse('^1.2.3'),
-          equals(new VersionConstraint.compatibleWith(v123)));
+      expect(VersionConstraint.parse('^1.2.3'),
+          equals(VersionConstraint.compatibleWith(v123)));
 
-      var min = new Version.parse('0.7.2-pre+1');
-      expect(new VersionConstraint.parse('^0.7.2-pre+1'),
-          equals(new VersionConstraint.compatibleWith(min)));
+      var min = Version.parse('0.7.2-pre+1');
+      expect(VersionConstraint.parse('^0.7.2-pre+1'),
+          equals(VersionConstraint.compatibleWith(min)));
     });
 
     test('does not allow "^" to be mixed with other constraints', () {
-      expect(() => new VersionConstraint.parse('>=1.2.3 ^1.0.0'),
+      expect(() => VersionConstraint.parse('>=1.2.3 ^1.0.0'),
           throwsFormatException);
-      expect(() => new VersionConstraint.parse('^1.0.0 <1.2.3'),
+      expect(() => VersionConstraint.parse('^1.0.0 <1.2.3'),
           throwsFormatException);
     });
 
     test('ignores whitespace around "^"', () {
-      var constraint = new VersionConstraint.parse(' ^ 1.2.3 ');
+      var constraint = VersionConstraint.parse(' ^ 1.2.3 ');
 
-      expect(constraint, equals(new VersionConstraint.compatibleWith(v123)));
+      expect(constraint, equals(VersionConstraint.compatibleWith(v123)));
     });
 
     test('throws FormatException on a bad string', () {
@@ -172,23 +163,23 @@
       ];
 
       for (var text in bad) {
-        expect(() => new VersionConstraint.parse(text), throwsFormatException);
+        expect(() => VersionConstraint.parse(text), throwsFormatException);
       }
     });
   });
 
   group('compatibleWith()', () {
     test('returns the range of compatible versions', () {
-      var constraint = new VersionConstraint.compatibleWith(v072);
+      var constraint = VersionConstraint.compatibleWith(v072);
 
       expect(
           constraint,
-          equals(new VersionRange(
+          equals(VersionRange(
               min: v072, includeMin: true, max: v072.nextBreaking)));
     });
 
     test('toString() uses "^"', () {
-      var constraint = new VersionConstraint.compatibleWith(v072);
+      var constraint = VersionConstraint.compatibleWith(v072);
 
       expect(constraint.toString(), equals('^0.7.2'));
     });
diff --git a/pkgs/pub_semver/test/version_range_test.dart b/pkgs/pub_semver/test/version_range_test.dart
index a24faae..cfd66d9 100644
--- a/pkgs/pub_semver/test/version_range_test.dart
+++ b/pkgs/pub_semver/test/version_range_test.dart
@@ -8,10 +8,10 @@
 
 import 'utils.dart';
 
-main() {
+void main() {
   group('constructor', () {
     test('takes a min and max', () {
-      var range = new VersionRange(min: v123, max: v124);
+      var range = VersionRange(min: v123, max: v124);
       expect(range.isAny, isFalse);
       expect(range.min, equals(v123));
       expect(range.max, equals(v124.firstPreRelease));
@@ -19,184 +19,175 @@
 
     group("doesn't make the max a pre-release if", () {
       test("it's already a pre-release", () {
-        expect(new VersionRange(max: new Version.parse("1.2.4-pre")).max,
-            equals(new Version.parse("1.2.4-pre")));
+        expect(VersionRange(max: Version.parse("1.2.4-pre")).max,
+            equals(Version.parse("1.2.4-pre")));
       });
 
       test("includeMax is true", () {
-        expect(new VersionRange(max: v124, includeMax: true).max, equals(v124));
+        expect(VersionRange(max: v124, includeMax: true).max, equals(v124));
       });
 
       test("min is a prerelease of max", () {
-        expect(
-            new VersionRange(min: new Version.parse("1.2.4-pre"), max: v124)
-                .max,
+        expect(VersionRange(min: Version.parse("1.2.4-pre"), max: v124).max,
             equals(v124));
       });
 
       test("max has a build identifier", () {
-        expect(new VersionRange(max: new Version.parse("1.2.4+1")).max,
-            equals(new Version.parse("1.2.4+1")));
+        expect(VersionRange(max: Version.parse("1.2.4+1")).max,
+            equals(Version.parse("1.2.4+1")));
       });
     });
 
     test('allows omitting max', () {
-      var range = new VersionRange(min: v123);
+      var range = VersionRange(min: v123);
       expect(range.isAny, isFalse);
       expect(range.min, equals(v123));
       expect(range.max, isNull);
     });
 
     test('allows omitting min and max', () {
-      var range = new VersionRange();
+      var range = VersionRange();
       expect(range.isAny, isTrue);
       expect(range.min, isNull);
       expect(range.max, isNull);
     });
 
     test('takes includeMin', () {
-      var range = new VersionRange(min: v123, includeMin: true);
+      var range = VersionRange(min: v123, includeMin: true);
       expect(range.includeMin, isTrue);
     });
 
     test('includeMin defaults to false if omitted', () {
-      var range = new VersionRange(min: v123);
+      var range = VersionRange(min: v123);
       expect(range.includeMin, isFalse);
     });
 
     test('takes includeMax', () {
-      var range = new VersionRange(max: v123, includeMax: true);
+      var range = VersionRange(max: v123, includeMax: true);
       expect(range.includeMax, isTrue);
     });
 
     test('includeMax defaults to false if omitted', () {
-      var range = new VersionRange(max: v123);
+      var range = VersionRange(max: v123);
       expect(range.includeMax, isFalse);
     });
 
     test('throws if min > max', () {
-      expect(() => new VersionRange(min: v124, max: v123), throwsArgumentError);
+      expect(() => VersionRange(min: v124, max: v123), throwsArgumentError);
     });
   });
 
   group('allows()', () {
     test('version must be greater than min', () {
-      var range = new VersionRange(min: v123);
+      var range = VersionRange(min: v123);
 
-      expect(range,
-          allows(new Version.parse('1.3.3'), new Version.parse('2.3.3')));
-      expect(range,
-          doesNotAllow(new Version.parse('1.2.2'), new Version.parse('1.2.3')));
+      expect(range, allows(Version.parse('1.3.3'), Version.parse('2.3.3')));
+      expect(
+          range, doesNotAllow(Version.parse('1.2.2'), Version.parse('1.2.3')));
     });
 
     test('version must be min or greater if includeMin', () {
-      var range = new VersionRange(min: v123, includeMin: true);
+      var range = VersionRange(min: v123, includeMin: true);
 
       expect(
           range,
-          allows(new Version.parse('1.2.3'), new Version.parse('1.3.3'),
-              new Version.parse('2.3.3')));
-      expect(range, doesNotAllow(new Version.parse('1.2.2')));
+          allows(Version.parse('1.2.3'), Version.parse('1.3.3'),
+              Version.parse('2.3.3')));
+      expect(range, doesNotAllow(Version.parse('1.2.2')));
     });
 
     test('pre-release versions of inclusive min are excluded', () {
-      var range = new VersionRange(min: v123, includeMin: true);
+      var range = VersionRange(min: v123, includeMin: true);
 
-      expect(range, allows(new Version.parse('1.2.4-dev')));
-      expect(range, doesNotAllow(new Version.parse('1.2.3-dev')));
+      expect(range, allows(Version.parse('1.2.4-dev')));
+      expect(range, doesNotAllow(Version.parse('1.2.3-dev')));
     });
 
     test('version must be less than max', () {
-      var range = new VersionRange(max: v234);
+      var range = VersionRange(max: v234);
 
-      expect(range, allows(new Version.parse('2.3.3')));
-      expect(range,
-          doesNotAllow(new Version.parse('2.3.4'), new Version.parse('2.4.3')));
+      expect(range, allows(Version.parse('2.3.3')));
+      expect(
+          range, doesNotAllow(Version.parse('2.3.4'), Version.parse('2.4.3')));
     });
 
     test('pre-release versions of non-pre-release max are excluded', () {
-      var range = new VersionRange(max: v234);
+      var range = VersionRange(max: v234);
 
-      expect(range, allows(new Version.parse('2.3.3')));
-      expect(
-          range,
-          doesNotAllow(
-              new Version.parse('2.3.4-dev'), new Version.parse('2.3.4')));
+      expect(range, allows(Version.parse('2.3.3')));
+      expect(range,
+          doesNotAllow(Version.parse('2.3.4-dev'), Version.parse('2.3.4')));
     });
 
     test(
         'pre-release versions of non-pre-release max are included if min is a '
         'pre-release of the same version', () {
-      var range =
-          new VersionRange(min: new Version.parse('2.3.4-dev.0'), max: v234);
+      var range = VersionRange(min: Version.parse('2.3.4-dev.0'), max: v234);
 
-      expect(range, allows(new Version.parse('2.3.4-dev.1')));
+      expect(range, allows(Version.parse('2.3.4-dev.1')));
       expect(
           range,
-          doesNotAllow(new Version.parse('2.3.3'),
-              new Version.parse('2.3.4-dev'), new Version.parse('2.3.4')));
+          doesNotAllow(Version.parse('2.3.3'), Version.parse('2.3.4-dev'),
+              Version.parse('2.3.4')));
     });
 
     test('pre-release versions of pre-release max are included', () {
-      var range = new VersionRange(max: new Version.parse('2.3.4-dev.2'));
+      var range = VersionRange(max: Version.parse('2.3.4-dev.2'));
 
-      expect(range, allows(new Version.parse('2.3.4-dev.1')));
+      expect(range, allows(Version.parse('2.3.4-dev.1')));
       expect(
           range,
-          doesNotAllow(new Version.parse('2.3.4-dev.2'),
-              new Version.parse('2.3.4-dev.3')));
+          doesNotAllow(
+              Version.parse('2.3.4-dev.2'), Version.parse('2.3.4-dev.3')));
     });
 
     test('version must be max or less if includeMax', () {
-      var range = new VersionRange(min: v123, max: v234, includeMax: true);
+      var range = VersionRange(min: v123, max: v234, includeMax: true);
 
       expect(
           range,
           allows(
-              new Version.parse('2.3.3'),
-              new Version.parse('2.3.4'),
+              Version.parse('2.3.3'),
+              Version.parse('2.3.4'),
               // Pre-releases of the max are allowed.
-              new Version.parse('2.3.4-dev')));
-      expect(range, doesNotAllow(new Version.parse('2.4.3')));
+              Version.parse('2.3.4-dev')));
+      expect(range, doesNotAllow(Version.parse('2.4.3')));
     });
 
     test('has no min if one was not set', () {
-      var range = new VersionRange(max: v123);
+      var range = VersionRange(max: v123);
 
-      expect(range, allows(new Version.parse('0.0.0')));
-      expect(range, doesNotAllow(new Version.parse('1.2.3')));
+      expect(range, allows(Version.parse('0.0.0')));
+      expect(range, doesNotAllow(Version.parse('1.2.3')));
     });
 
     test('has no max if one was not set', () {
-      var range = new VersionRange(min: v123);
+      var range = VersionRange(min: v123);
 
-      expect(range,
-          allows(new Version.parse('1.3.3'), new Version.parse('999.3.3')));
-      expect(range, doesNotAllow(new Version.parse('1.2.3')));
+      expect(range, allows(Version.parse('1.3.3'), Version.parse('999.3.3')));
+      expect(range, doesNotAllow(Version.parse('1.2.3')));
     });
 
     test('allows any version if there is no min or max', () {
-      var range = new VersionRange();
+      var range = VersionRange();
 
-      expect(range,
-          allows(new Version.parse('0.0.0'), new Version.parse('999.99.9')));
+      expect(range, allows(Version.parse('0.0.0'), Version.parse('999.99.9')));
     });
 
     test('allows pre-releases of the max with includeMaxPreRelease', () {
-      expect(includeMaxPreReleaseRange, allows(new Version.parse('2.0.0-dev')));
+      expect(includeMaxPreReleaseRange, allows(Version.parse('2.0.0-dev')));
     });
   });
 
   group('allowsAll()', () {
     test('allows an empty constraint', () {
       expect(
-          new VersionRange(min: v123, max: v250)
-              .allowsAll(VersionConstraint.empty),
+          VersionRange(min: v123, max: v250).allowsAll(VersionConstraint.empty),
           isTrue);
     });
 
     test('allows allowed versions', () {
-      var range = new VersionRange(min: v123, max: v250, includeMax: true);
+      var range = VersionRange(min: v123, max: v250, includeMax: true);
       expect(range.allowsAll(v123), isFalse);
       expect(range.allowsAll(v124), isTrue);
       expect(range.allowsAll(v250), isTrue);
@@ -204,38 +195,38 @@
     });
 
     test('with no min', () {
-      var range = new VersionRange(max: v250);
-      expect(range.allowsAll(new VersionRange(min: v080, max: v140)), isTrue);
-      expect(range.allowsAll(new VersionRange(min: v080, max: v300)), isFalse);
-      expect(range.allowsAll(new VersionRange(max: v140)), isTrue);
-      expect(range.allowsAll(new VersionRange(max: v300)), isFalse);
+      var range = VersionRange(max: v250);
+      expect(range.allowsAll(VersionRange(min: v080, max: v140)), isTrue);
+      expect(range.allowsAll(VersionRange(min: v080, max: v300)), isFalse);
+      expect(range.allowsAll(VersionRange(max: v140)), isTrue);
+      expect(range.allowsAll(VersionRange(max: v300)), isFalse);
       expect(range.allowsAll(range), isTrue);
       expect(range.allowsAll(VersionConstraint.any), isFalse);
     });
 
     test('with no max', () {
-      var range = new VersionRange(min: v010);
-      expect(range.allowsAll(new VersionRange(min: v080, max: v140)), isTrue);
-      expect(range.allowsAll(new VersionRange(min: v003, max: v140)), isFalse);
-      expect(range.allowsAll(new VersionRange(min: v080)), isTrue);
-      expect(range.allowsAll(new VersionRange(min: v003)), isFalse);
+      var range = VersionRange(min: v010);
+      expect(range.allowsAll(VersionRange(min: v080, max: v140)), isTrue);
+      expect(range.allowsAll(VersionRange(min: v003, max: v140)), isFalse);
+      expect(range.allowsAll(VersionRange(min: v080)), isTrue);
+      expect(range.allowsAll(VersionRange(min: v003)), isFalse);
       expect(range.allowsAll(range), isTrue);
       expect(range.allowsAll(VersionConstraint.any), isFalse);
     });
 
     test('with a min and max', () {
-      var range = new VersionRange(min: v010, max: v250);
-      expect(range.allowsAll(new VersionRange(min: v080, max: v140)), isTrue);
-      expect(range.allowsAll(new VersionRange(min: v080, max: v300)), isFalse);
-      expect(range.allowsAll(new VersionRange(min: v003, max: v140)), isFalse);
-      expect(range.allowsAll(new VersionRange(min: v080)), isFalse);
-      expect(range.allowsAll(new VersionRange(max: v140)), isFalse);
+      var range = VersionRange(min: v010, max: v250);
+      expect(range.allowsAll(VersionRange(min: v080, max: v140)), isTrue);
+      expect(range.allowsAll(VersionRange(min: v080, max: v300)), isFalse);
+      expect(range.allowsAll(VersionRange(min: v003, max: v140)), isFalse);
+      expect(range.allowsAll(VersionRange(min: v080)), isFalse);
+      expect(range.allowsAll(VersionRange(max: v140)), isFalse);
       expect(range.allowsAll(range), isTrue);
     });
 
     test("allows a bordering range that's not more inclusive", () {
-      var exclusive = new VersionRange(min: v010, max: v250);
-      var inclusive = new VersionRange(
+      var exclusive = VersionRange(min: v010, max: v250);
+      var inclusive = VersionRange(
           min: v010, includeMin: true, max: v250, includeMax: true);
       expect(inclusive.allowsAll(exclusive), isTrue);
       expect(inclusive.allowsAll(inclusive), isTrue);
@@ -244,66 +235,59 @@
     });
 
     test('allows unions that are completely contained', () {
-      var range = new VersionRange(min: v114, max: v200);
-      expect(
-          range.allowsAll(new VersionRange(min: v123, max: v124).union(v140)),
+      var range = VersionRange(min: v114, max: v200);
+      expect(range.allowsAll(VersionRange(min: v123, max: v124).union(v140)),
           isTrue);
-      expect(
-          range.allowsAll(new VersionRange(min: v010, max: v124).union(v140)),
+      expect(range.allowsAll(VersionRange(min: v010, max: v124).union(v140)),
           isFalse);
-      expect(
-          range.allowsAll(new VersionRange(min: v123, max: v234).union(v140)),
+      expect(range.allowsAll(VersionRange(min: v123, max: v234).union(v140)),
           isFalse);
     });
 
     group('pre-release versions', () {
       test('of inclusive min are excluded', () {
-        var range = new VersionRange(min: v123, includeMin: true);
+        var range = VersionRange(min: v123, includeMin: true);
 
-        expect(
-            range.allowsAll(new VersionConstraint.parse('>1.2.4-dev')), isTrue);
-        expect(range.allowsAll(new VersionConstraint.parse('>1.2.3-dev')),
-            isFalse);
+        expect(range.allowsAll(VersionConstraint.parse('>1.2.4-dev')), isTrue);
+        expect(range.allowsAll(VersionConstraint.parse('>1.2.3-dev')), isFalse);
       });
 
       test('of non-pre-release max are excluded', () {
-        var range = new VersionRange(max: v234);
+        var range = VersionRange(max: v234);
 
-        expect(range.allowsAll(new VersionConstraint.parse('<2.3.3')), isTrue);
-        expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev')),
-            isFalse);
+        expect(range.allowsAll(VersionConstraint.parse('<2.3.3')), isTrue);
+        expect(range.allowsAll(VersionConstraint.parse('<2.3.4-dev')), isFalse);
       });
 
       test('of non-pre-release max are included with includeMaxPreRelease', () {
         expect(
             includeMaxPreReleaseRange
-                .allowsAll(new VersionConstraint.parse('<2.0.0-dev')),
+                .allowsAll(VersionConstraint.parse('<2.0.0-dev')),
             isTrue);
       });
 
       test(
           'of non-pre-release max are included if min is a pre-release of the '
           'same version', () {
-        var range =
-            new VersionRange(min: new Version.parse('2.3.4-dev.0'), max: v234);
+        var range = VersionRange(min: Version.parse('2.3.4-dev.0'), max: v234);
 
         expect(
             range.allowsAll(
-                new VersionConstraint.parse('>2.3.4-dev.0 <2.3.4-dev.1')),
+                VersionConstraint.parse('>2.3.4-dev.0 <2.3.4-dev.1')),
             isTrue);
       });
 
       test('of pre-release max are included', () {
-        var range = new VersionRange(max: new Version.parse('2.3.4-dev.2'));
+        var range = VersionRange(max: Version.parse('2.3.4-dev.2'));
 
-        expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev.1')),
-            isTrue);
-        expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev.2')),
-            isTrue);
-        expect(range.allowsAll(new VersionConstraint.parse('<=2.3.4-dev.2')),
-            isFalse);
-        expect(range.allowsAll(new VersionConstraint.parse('<2.3.4-dev.3')),
-            isFalse);
+        expect(
+            range.allowsAll(VersionConstraint.parse('<2.3.4-dev.1')), isTrue);
+        expect(
+            range.allowsAll(VersionConstraint.parse('<2.3.4-dev.2')), isTrue);
+        expect(
+            range.allowsAll(VersionConstraint.parse('<=2.3.4-dev.2')), isFalse);
+        expect(
+            range.allowsAll(VersionConstraint.parse('<2.3.4-dev.3')), isFalse);
       });
     });
   });
@@ -311,13 +295,12 @@
   group('allowsAny()', () {
     test('disallows an empty constraint', () {
       expect(
-          new VersionRange(min: v123, max: v250)
-              .allowsAny(VersionConstraint.empty),
+          VersionRange(min: v123, max: v250).allowsAny(VersionConstraint.empty),
           isFalse);
     });
 
     test('allows allowed versions', () {
-      var range = new VersionRange(min: v123, max: v250, includeMax: true);
+      var range = VersionRange(min: v123, max: v250, includeMax: true);
       expect(range.allowsAny(v123), isFalse);
       expect(range.allowsAny(v124), isTrue);
       expect(range.allowsAny(v250), isTrue);
@@ -325,135 +308,127 @@
     });
 
     test('with no min', () {
-      var range = new VersionRange(max: v200);
-      expect(range.allowsAny(new VersionRange(min: v140, max: v300)), isTrue);
-      expect(range.allowsAny(new VersionRange(min: v234, max: v300)), isFalse);
-      expect(range.allowsAny(new VersionRange(min: v140)), isTrue);
-      expect(range.allowsAny(new VersionRange(min: v234)), isFalse);
+      var range = VersionRange(max: v200);
+      expect(range.allowsAny(VersionRange(min: v140, max: v300)), isTrue);
+      expect(range.allowsAny(VersionRange(min: v234, max: v300)), isFalse);
+      expect(range.allowsAny(VersionRange(min: v140)), isTrue);
+      expect(range.allowsAny(VersionRange(min: v234)), isFalse);
       expect(range.allowsAny(range), isTrue);
     });
 
     test('with no max', () {
-      var range = new VersionRange(min: v072);
-      expect(range.allowsAny(new VersionRange(min: v003, max: v140)), isTrue);
-      expect(range.allowsAny(new VersionRange(min: v003, max: v010)), isFalse);
-      expect(range.allowsAny(new VersionRange(max: v080)), isTrue);
-      expect(range.allowsAny(new VersionRange(max: v003)), isFalse);
+      var range = VersionRange(min: v072);
+      expect(range.allowsAny(VersionRange(min: v003, max: v140)), isTrue);
+      expect(range.allowsAny(VersionRange(min: v003, max: v010)), isFalse);
+      expect(range.allowsAny(VersionRange(max: v080)), isTrue);
+      expect(range.allowsAny(VersionRange(max: v003)), isFalse);
       expect(range.allowsAny(range), isTrue);
     });
 
     test('with a min and max', () {
-      var range = new VersionRange(min: v072, max: v200);
-      expect(range.allowsAny(new VersionRange(min: v003, max: v140)), isTrue);
-      expect(range.allowsAny(new VersionRange(min: v140, max: v300)), isTrue);
-      expect(range.allowsAny(new VersionRange(min: v003, max: v010)), isFalse);
-      expect(range.allowsAny(new VersionRange(min: v234, max: v300)), isFalse);
-      expect(range.allowsAny(new VersionRange(max: v010)), isFalse);
-      expect(range.allowsAny(new VersionRange(min: v234)), isFalse);
+      var range = VersionRange(min: v072, max: v200);
+      expect(range.allowsAny(VersionRange(min: v003, max: v140)), isTrue);
+      expect(range.allowsAny(VersionRange(min: v140, max: v300)), isTrue);
+      expect(range.allowsAny(VersionRange(min: v003, max: v010)), isFalse);
+      expect(range.allowsAny(VersionRange(min: v234, max: v300)), isFalse);
+      expect(range.allowsAny(VersionRange(max: v010)), isFalse);
+      expect(range.allowsAny(VersionRange(min: v234)), isFalse);
       expect(range.allowsAny(range), isTrue);
     });
 
     test('allows a bordering range when both are inclusive', () {
-      expect(new VersionRange(max: v250).allowsAny(new VersionRange(min: v250)),
+      expect(
+          VersionRange(max: v250).allowsAny(VersionRange(min: v250)), isFalse);
+
+      expect(
+          VersionRange(max: v250, includeMax: true)
+              .allowsAny(VersionRange(min: v250)),
           isFalse);
 
       expect(
-          new VersionRange(max: v250, includeMax: true)
-              .allowsAny(new VersionRange(min: v250)),
+          VersionRange(max: v250)
+              .allowsAny(VersionRange(min: v250, includeMin: true)),
           isFalse);
 
       expect(
-          new VersionRange(max: v250)
-              .allowsAny(new VersionRange(min: v250, includeMin: true)),
-          isFalse);
-
-      expect(
-          new VersionRange(max: v250, includeMax: true)
-              .allowsAny(new VersionRange(min: v250, includeMin: true)),
+          VersionRange(max: v250, includeMax: true)
+              .allowsAny(VersionRange(min: v250, includeMin: true)),
           isTrue);
 
-      expect(new VersionRange(min: v250).allowsAny(new VersionRange(max: v250)),
+      expect(
+          VersionRange(min: v250).allowsAny(VersionRange(max: v250)), isFalse);
+
+      expect(
+          VersionRange(min: v250, includeMin: true)
+              .allowsAny(VersionRange(max: v250)),
           isFalse);
 
       expect(
-          new VersionRange(min: v250, includeMin: true)
-              .allowsAny(new VersionRange(max: v250)),
+          VersionRange(min: v250)
+              .allowsAny(VersionRange(max: v250, includeMax: true)),
           isFalse);
 
       expect(
-          new VersionRange(min: v250)
-              .allowsAny(new VersionRange(max: v250, includeMax: true)),
-          isFalse);
-
-      expect(
-          new VersionRange(min: v250, includeMin: true)
-              .allowsAny(new VersionRange(max: v250, includeMax: true)),
+          VersionRange(min: v250, includeMin: true)
+              .allowsAny(VersionRange(max: v250, includeMax: true)),
           isTrue);
     });
 
     test('allows unions that are partially contained', () {
-      var range = new VersionRange(min: v114, max: v200);
-      expect(
-          range.allowsAny(new VersionRange(min: v010, max: v080).union(v140)),
+      var range = VersionRange(min: v114, max: v200);
+      expect(range.allowsAny(VersionRange(min: v010, max: v080).union(v140)),
           isTrue);
-      expect(
-          range.allowsAny(new VersionRange(min: v123, max: v234).union(v300)),
+      expect(range.allowsAny(VersionRange(min: v123, max: v234).union(v300)),
           isTrue);
-      expect(
-          range.allowsAny(new VersionRange(min: v234, max: v300).union(v010)),
+      expect(range.allowsAny(VersionRange(min: v234, max: v300).union(v010)),
           isFalse);
     });
 
     group('pre-release versions', () {
       test('of inclusive min are excluded', () {
-        var range = new VersionRange(min: v123, includeMin: true);
+        var range = VersionRange(min: v123, includeMin: true);
 
-        expect(
-            range.allowsAny(new VersionConstraint.parse('<1.2.4-dev')), isTrue);
-        expect(range.allowsAny(new VersionConstraint.parse('<1.2.3-dev')),
-            isFalse);
+        expect(range.allowsAny(VersionConstraint.parse('<1.2.4-dev')), isTrue);
+        expect(range.allowsAny(VersionConstraint.parse('<1.2.3-dev')), isFalse);
       });
 
       test('of non-pre-release max are excluded', () {
-        var range = new VersionRange(max: v234);
+        var range = VersionRange(max: v234);
 
-        expect(range.allowsAny(new VersionConstraint.parse('>2.3.3')), isTrue);
-        expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev')),
-            isFalse);
+        expect(range.allowsAny(VersionConstraint.parse('>2.3.3')), isTrue);
+        expect(range.allowsAny(VersionConstraint.parse('>2.3.4-dev')), isFalse);
       });
 
       test('of non-pre-release max are included with includeMaxPreRelease', () {
         expect(
             includeMaxPreReleaseRange
-                .allowsAny(new VersionConstraint.parse('>2.0.0-dev')),
+                .allowsAny(VersionConstraint.parse('>2.0.0-dev')),
             isTrue);
       });
 
       test(
           'of non-pre-release max are included if min is a pre-release of the '
           'same version', () {
-        var range =
-            new VersionRange(min: new Version.parse('2.3.4-dev.0'), max: v234);
+        var range = VersionRange(min: Version.parse('2.3.4-dev.0'), max: v234);
 
-        expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.1')),
-            isTrue);
-        expect(range.allowsAny(new VersionConstraint.parse('>2.3.4')), isFalse);
+        expect(
+            range.allowsAny(VersionConstraint.parse('>2.3.4-dev.1')), isTrue);
+        expect(range.allowsAny(VersionConstraint.parse('>2.3.4')), isFalse);
 
-        expect(range.allowsAny(new VersionConstraint.parse('<2.3.4-dev.1')),
-            isTrue);
-        expect(range.allowsAny(new VersionConstraint.parse('<2.3.4-dev')),
-            isFalse);
+        expect(
+            range.allowsAny(VersionConstraint.parse('<2.3.4-dev.1')), isTrue);
+        expect(range.allowsAny(VersionConstraint.parse('<2.3.4-dev')), isFalse);
       });
 
       test('of pre-release max are included', () {
-        var range = new VersionConstraint.parse('<2.3.4-dev.2');
+        var range = VersionConstraint.parse('<2.3.4-dev.2');
 
-        expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.1')),
-            isTrue);
-        expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.2')),
-            isFalse);
-        expect(range.allowsAny(new VersionConstraint.parse('>2.3.4-dev.3')),
-            isFalse);
+        expect(
+            range.allowsAny(VersionConstraint.parse('>2.3.4-dev.1')), isTrue);
+        expect(
+            range.allowsAny(VersionConstraint.parse('>2.3.4-dev.2')), isFalse);
+        expect(
+            range.allowsAny(VersionConstraint.parse('>2.3.4-dev.3')), isFalse);
       });
     });
   });
@@ -461,78 +436,77 @@
   group('intersect()', () {
     test('two overlapping ranges', () {
       expect(
-          new VersionRange(min: v123, max: v250)
-              .intersect(new VersionRange(min: v200, max: v300)),
-          equals(new VersionRange(min: v200, max: v250)));
+          VersionRange(min: v123, max: v250)
+              .intersect(VersionRange(min: v200, max: v300)),
+          equals(VersionRange(min: v200, max: v250)));
     });
 
     test('a non-overlapping range allows no versions', () {
-      var a = new VersionRange(min: v114, max: v124);
-      var b = new VersionRange(min: v200, max: v250);
+      var a = VersionRange(min: v114, max: v124);
+      var b = VersionRange(min: v200, max: v250);
       expect(a.intersect(b).isEmpty, isTrue);
     });
 
     test('adjacent ranges allow no versions if exclusive', () {
-      var a = new VersionRange(min: v114, max: v124);
-      var b = new VersionRange(min: v124, max: v200);
+      var a = VersionRange(min: v114, max: v124);
+      var b = VersionRange(min: v124, max: v200);
       expect(a.intersect(b).isEmpty, isTrue);
     });
 
     test('adjacent ranges allow version if inclusive', () {
-      var a = new VersionRange(min: v114, max: v124, includeMax: true);
-      var b = new VersionRange(min: v124, max: v200, includeMin: true);
+      var a = VersionRange(min: v114, max: v124, includeMax: true);
+      var b = VersionRange(min: v124, max: v200, includeMin: true);
       expect(a.intersect(b), equals(v124));
     });
 
     test('with an open range', () {
-      var open = new VersionRange();
-      var a = new VersionRange(min: v114, max: v124);
+      var open = VersionRange();
+      var a = VersionRange(min: v114, max: v124);
       expect(open.intersect(open), equals(open));
       expect(a.intersect(open), equals(a));
     });
 
     test('returns the version if the range allows it', () {
+      expect(VersionRange(min: v114, max: v124).intersect(v123), equals(v123));
       expect(
-          new VersionRange(min: v114, max: v124).intersect(v123), equals(v123));
-      expect(new VersionRange(min: v123, max: v124).intersect(v114).isEmpty,
-          isTrue);
+          VersionRange(min: v123, max: v124).intersect(v114).isEmpty, isTrue);
     });
 
     test("with a range with a pre-release min, returns an empty constraint",
         () {
       expect(
-          new VersionRange(max: v200)
-              .intersect(new VersionConstraint.parse(">=2.0.0-dev")),
+          VersionRange(max: v200)
+              .intersect(VersionConstraint.parse(">=2.0.0-dev")),
           equals(VersionConstraint.empty));
     });
 
     test("with a range with a pre-release max, returns the original", () {
       expect(
-          new VersionRange(max: v200)
-              .intersect(new VersionConstraint.parse("<2.0.0-dev")),
-          equals(new VersionRange(max: v200)));
+          VersionRange(max: v200)
+              .intersect(VersionConstraint.parse("<2.0.0-dev")),
+          equals(VersionRange(max: v200)));
     });
 
     group("with includeMaxPreRelease", () {
       test('preserves includeMaxPreRelease if the max version is included', () {
         expect(
             includeMaxPreReleaseRange
-                .intersect(new VersionConstraint.parse("<1.0.0")),
-            equals(new VersionConstraint.parse("<1.0.0")));
+                .intersect(VersionConstraint.parse("<1.0.0")),
+            equals(VersionConstraint.parse("<1.0.0")));
         expect(
             includeMaxPreReleaseRange
-                .intersect(new VersionConstraint.parse("<2.0.0")),
-            equals(new VersionConstraint.parse("<2.0.0")));
+                .intersect(VersionConstraint.parse("<2.0.0")),
+            equals(VersionConstraint.parse("<2.0.0")));
         expect(includeMaxPreReleaseRange.intersect(includeMaxPreReleaseRange),
             equals(includeMaxPreReleaseRange));
         expect(
             includeMaxPreReleaseRange
-                .intersect(new VersionConstraint.parse("<3.0.0")),
+                .intersect(VersionConstraint.parse("<3.0.0")),
             equals(includeMaxPreReleaseRange));
         expect(
             includeMaxPreReleaseRange
-                .intersect(new VersionConstraint.parse(">1.1.4")),
-            equals(new VersionRange(
+                .intersect(VersionConstraint.parse(">1.1.4")),
+            equals(VersionRange(
                 min: v114, max: v200, alwaysIncludeMaxPreRelease: true)));
       });
 
@@ -541,8 +515,8 @@
           "an intersection", () {
         expect(
             includeMaxPreReleaseRange
-                .intersect(new VersionConstraint.parse(">=2.0.0-dev")),
-            equals(new VersionConstraint.parse(">=2.0.0-dev <2.0.0")));
+                .intersect(VersionConstraint.parse(">=2.0.0-dev")),
+            equals(VersionConstraint.parse(">=2.0.0-dev <2.0.0")));
       });
 
       test(
@@ -550,142 +524,136 @@
           "the narrower constraint", () {
         expect(
             includeMaxPreReleaseRange
-                .intersect(new VersionConstraint.parse("<2.0.0-dev")),
-            equals(new VersionConstraint.parse("<2.0.0-dev")));
+                .intersect(VersionConstraint.parse("<2.0.0-dev")),
+            equals(VersionConstraint.parse("<2.0.0-dev")));
       });
     });
   });
 
   group('union()', () {
     test("with a version returns the range if it contains the version", () {
-      var range = new VersionRange(min: v114, max: v124);
+      var range = VersionRange(min: v114, max: v124);
       expect(range.union(v123), equals(range));
     });
 
     test("with a version on the edge of the range, expands the range", () {
       expect(
-          new VersionRange(
-                  min: v114, max: v124, alwaysIncludeMaxPreRelease: true)
+          VersionRange(min: v114, max: v124, alwaysIncludeMaxPreRelease: true)
               .union(v124),
-          equals(new VersionRange(min: v114, max: v124, includeMax: true)));
-      expect(new VersionRange(min: v114, max: v124).union(v114),
-          equals(new VersionRange(min: v114, max: v124, includeMin: true)));
+          equals(VersionRange(min: v114, max: v124, includeMax: true)));
+      expect(VersionRange(min: v114, max: v124).union(v114),
+          equals(VersionRange(min: v114, max: v124, includeMin: true)));
     });
 
     test(
         "with a version allows both the range and the version if the range "
         "doesn't contain the version", () {
-      var result = new VersionRange(min: v003, max: v114).union(v124);
+      var result = VersionRange(min: v003, max: v114).union(v124);
       expect(result, allows(v010));
       expect(result, doesNotAllow(v123));
       expect(result, allows(v124));
     });
 
     test("returns a VersionUnion for a disjoint range", () {
-      var result = new VersionRange(min: v003, max: v114)
-          .union(new VersionRange(min: v130, max: v200));
+      var result = VersionRange(min: v003, max: v114)
+          .union(VersionRange(min: v130, max: v200));
       expect(result, allows(v080));
       expect(result, doesNotAllow(v123));
       expect(result, allows(v140));
     });
 
     test("considers open ranges disjoint", () {
-      var result = new VersionRange(min: v003, max: v114)
-          .union(new VersionRange(min: v114, max: v200));
+      var result = VersionRange(min: v003, max: v114)
+          .union(VersionRange(min: v114, max: v200));
       expect(result, allows(v080));
       expect(result, doesNotAllow(v114));
       expect(result, allows(v140));
 
-      result = new VersionRange(min: v114, max: v200)
-          .union(new VersionRange(min: v003, max: v114));
+      result = VersionRange(min: v114, max: v200)
+          .union(VersionRange(min: v003, max: v114));
       expect(result, allows(v080));
       expect(result, doesNotAllow(v114));
       expect(result, allows(v140));
     });
 
     test("returns a merged range for an overlapping range", () {
-      var result = new VersionRange(min: v003, max: v114)
-          .union(new VersionRange(min: v080, max: v200));
-      expect(result, equals(new VersionRange(min: v003, max: v200)));
+      var result = VersionRange(min: v003, max: v114)
+          .union(VersionRange(min: v080, max: v200));
+      expect(result, equals(VersionRange(min: v003, max: v200)));
     });
 
     test("considers closed ranges overlapping", () {
-      var result = new VersionRange(min: v003, max: v114, includeMax: true)
-          .union(new VersionRange(min: v114, max: v200));
-      expect(result, equals(new VersionRange(min: v003, max: v200)));
+      var result = VersionRange(min: v003, max: v114, includeMax: true)
+          .union(VersionRange(min: v114, max: v200));
+      expect(result, equals(VersionRange(min: v003, max: v200)));
 
-      result = new VersionRange(
-              min: v003, max: v114, alwaysIncludeMaxPreRelease: true)
-          .union(new VersionRange(min: v114, max: v200, includeMin: true));
-      expect(result, equals(new VersionRange(min: v003, max: v200)));
+      result =
+          VersionRange(min: v003, max: v114, alwaysIncludeMaxPreRelease: true)
+              .union(VersionRange(min: v114, max: v200, includeMin: true));
+      expect(result, equals(VersionRange(min: v003, max: v200)));
 
-      result = new VersionRange(min: v114, max: v200)
-          .union(new VersionRange(min: v003, max: v114, includeMax: true));
-      expect(result, equals(new VersionRange(min: v003, max: v200)));
+      result = VersionRange(min: v114, max: v200)
+          .union(VersionRange(min: v003, max: v114, includeMax: true));
+      expect(result, equals(VersionRange(min: v003, max: v200)));
 
-      result = new VersionRange(min: v114, max: v200, includeMin: true).union(
-          new VersionRange(
-              min: v003, max: v114, alwaysIncludeMaxPreRelease: true));
-      expect(result, equals(new VersionRange(min: v003, max: v200)));
+      result = VersionRange(min: v114, max: v200, includeMin: true).union(
+          VersionRange(min: v003, max: v114, alwaysIncludeMaxPreRelease: true));
+      expect(result, equals(VersionRange(min: v003, max: v200)));
     });
 
     test("includes edges if either range does", () {
-      var result = new VersionRange(min: v003, max: v114, includeMin: true)
-          .union(new VersionRange(min: v003, max: v114, includeMax: true));
+      var result = VersionRange(min: v003, max: v114, includeMin: true)
+          .union(VersionRange(min: v003, max: v114, includeMax: true));
       expect(
           result,
-          equals(new VersionRange(
+          equals(VersionRange(
               min: v003, max: v114, includeMin: true, includeMax: true)));
     });
 
     test("with a range with a pre-release min, returns a constraint with a gap",
         () {
-      var result = new VersionRange(max: v200)
-          .union(new VersionConstraint.parse(">=2.0.0-dev"));
+      var result =
+          VersionRange(max: v200).union(VersionConstraint.parse(">=2.0.0-dev"));
       expect(result, allows(v140));
-      expect(result, doesNotAllow(new Version.parse("2.0.0-alpha")));
-      expect(result, allows(new Version.parse("2.0.0-dev")));
-      expect(result, allows(new Version.parse("2.0.0-dev.1")));
-      expect(result, allows(new Version.parse("2.0.0")));
+      expect(result, doesNotAllow(Version.parse("2.0.0-alpha")));
+      expect(result, allows(Version.parse("2.0.0-dev")));
+      expect(result, allows(Version.parse("2.0.0-dev.1")));
+      expect(result, allows(Version.parse("2.0.0")));
     });
 
     test("with a range with a pre-release max, returns the larger constraint",
         () {
       expect(
-          new VersionRange(max: v200)
-              .union(new VersionConstraint.parse("<2.0.0-dev")),
-          equals(new VersionConstraint.parse("<2.0.0-dev")));
+          VersionRange(max: v200).union(VersionConstraint.parse("<2.0.0-dev")),
+          equals(VersionConstraint.parse("<2.0.0-dev")));
     });
 
     group("with includeMaxPreRelease", () {
       test('adds includeMaxPreRelease if the max version is included', () {
         expect(
-            includeMaxPreReleaseRange
-                .union(new VersionConstraint.parse("<1.0.0")),
+            includeMaxPreReleaseRange.union(VersionConstraint.parse("<1.0.0")),
             equals(includeMaxPreReleaseRange));
         expect(includeMaxPreReleaseRange.union(includeMaxPreReleaseRange),
             equals(includeMaxPreReleaseRange));
         expect(
-            includeMaxPreReleaseRange
-                .union(new VersionConstraint.parse("<2.0.0")),
+            includeMaxPreReleaseRange.union(VersionConstraint.parse("<2.0.0")),
             equals(includeMaxPreReleaseRange));
         expect(
-            includeMaxPreReleaseRange
-                .union(new VersionConstraint.parse("<3.0.0")),
-            equals(new VersionConstraint.parse("<3.0.0")));
+            includeMaxPreReleaseRange.union(VersionConstraint.parse("<3.0.0")),
+            equals(VersionConstraint.parse("<3.0.0")));
       });
 
       test("and a range with a pre-release min, returns any", () {
         expect(
             includeMaxPreReleaseRange
-                .union(new VersionConstraint.parse(">=2.0.0-dev")),
+                .union(VersionConstraint.parse(">=2.0.0-dev")),
             equals(VersionConstraint.any));
       });
 
       test("and a range with a pre-release max, returns the original", () {
         expect(
             includeMaxPreReleaseRange
-                .union(new VersionConstraint.parse("<2.0.0-dev")),
+                .union(VersionConstraint.parse("<2.0.0-dev")),
             equals(includeMaxPreReleaseRange));
       });
     });
@@ -694,127 +662,124 @@
   group('difference()', () {
     test("with an empty range returns the original range", () {
       expect(
-          new VersionRange(min: v003, max: v114)
+          VersionRange(min: v003, max: v114)
               .difference(VersionConstraint.empty),
-          equals(new VersionRange(min: v003, max: v114)));
+          equals(VersionRange(min: v003, max: v114)));
     });
 
     test("with a version outside the range returns the original range", () {
-      expect(new VersionRange(min: v003, max: v114).difference(v200),
-          equals(new VersionRange(min: v003, max: v114)));
+      expect(VersionRange(min: v003, max: v114).difference(v200),
+          equals(VersionRange(min: v003, max: v114)));
     });
 
     test("with a version in the range splits the range", () {
       expect(
-          new VersionRange(min: v003, max: v114).difference(v072),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(
+          VersionRange(min: v003, max: v114).difference(v072),
+          equals(VersionConstraint.unionOf([
+            VersionRange(
                 min: v003, max: v072, alwaysIncludeMaxPreRelease: true),
-            new VersionRange(min: v072, max: v114)
+            VersionRange(min: v072, max: v114)
           ])));
     });
 
     test("with the max version makes the max exclusive", () {
       expect(
-          new VersionRange(min: v003, max: v114, includeMax: true)
-              .difference(v114),
-          equals(new VersionRange(
+          VersionRange(min: v003, max: v114, includeMax: true).difference(v114),
+          equals(VersionRange(
               min: v003, max: v114, alwaysIncludeMaxPreRelease: true)));
     });
 
     test("with the min version makes the min exclusive", () {
       expect(
-          new VersionRange(min: v003, max: v114, includeMin: true)
-              .difference(v003),
-          equals(new VersionRange(min: v003, max: v114)));
+          VersionRange(min: v003, max: v114, includeMin: true).difference(v003),
+          equals(VersionRange(min: v003, max: v114)));
     });
 
     test("with a disjoint range returns the original", () {
       expect(
-          new VersionRange(min: v003, max: v114)
-              .difference(new VersionRange(min: v123, max: v140)),
-          equals(new VersionRange(min: v003, max: v114)));
+          VersionRange(min: v003, max: v114)
+              .difference(VersionRange(min: v123, max: v140)),
+          equals(VersionRange(min: v003, max: v114)));
     });
 
     test("with an adjacent range returns the original", () {
       expect(
-          new VersionRange(min: v003, max: v114, includeMax: true)
-              .difference(new VersionRange(min: v114, max: v140)),
-          equals(new VersionRange(min: v003, max: v114, includeMax: true)));
+          VersionRange(min: v003, max: v114, includeMax: true)
+              .difference(VersionRange(min: v114, max: v140)),
+          equals(VersionRange(min: v003, max: v114, includeMax: true)));
     });
 
     test("with a range at the beginning cuts off the beginning of the range",
         () {
       expect(
-          new VersionRange(min: v080, max: v130)
-              .difference(new VersionRange(min: v010, max: v114)),
-          equals(new VersionConstraint.parse(">=1.1.4-0 <1.3.0")));
+          VersionRange(min: v080, max: v130)
+              .difference(VersionRange(min: v010, max: v114)),
+          equals(VersionConstraint.parse(">=1.1.4-0 <1.3.0")));
       expect(
-          new VersionRange(min: v080, max: v130)
-              .difference(new VersionRange(max: v114)),
-          equals(new VersionConstraint.parse(">=1.1.4-0 <1.3.0")));
+          VersionRange(min: v080, max: v130)
+              .difference(VersionRange(max: v114)),
+          equals(VersionConstraint.parse(">=1.1.4-0 <1.3.0")));
       expect(
-          new VersionRange(min: v080, max: v130).difference(
-              new VersionRange(min: v010, max: v114, includeMax: true)),
-          equals(new VersionRange(min: v114, max: v130)));
+          VersionRange(min: v080, max: v130)
+              .difference(VersionRange(min: v010, max: v114, includeMax: true)),
+          equals(VersionRange(min: v114, max: v130)));
       expect(
-          new VersionRange(min: v080, max: v130, includeMin: true).difference(
-              new VersionRange(min: v010, max: v080, includeMax: true)),
-          equals(new VersionRange(min: v080, max: v130)));
+          VersionRange(min: v080, max: v130, includeMin: true)
+              .difference(VersionRange(min: v010, max: v080, includeMax: true)),
+          equals(VersionRange(min: v080, max: v130)));
       expect(
-          new VersionRange(min: v080, max: v130, includeMax: true)
-              .difference(new VersionRange(min: v080, max: v130)),
-          equals(new VersionConstraint.parse(">=1.3.0-0 <=1.3.0")));
+          VersionRange(min: v080, max: v130, includeMax: true)
+              .difference(VersionRange(min: v080, max: v130)),
+          equals(VersionConstraint.parse(">=1.3.0-0 <=1.3.0")));
     });
 
     test("with a range at the end cuts off the end of the range", () {
       expect(
-          new VersionRange(min: v080, max: v130)
-              .difference(new VersionRange(min: v114, max: v140)),
-          equals(new VersionRange(min: v080, max: v114, includeMax: true)));
+          VersionRange(min: v080, max: v130)
+              .difference(VersionRange(min: v114, max: v140)),
+          equals(VersionRange(min: v080, max: v114, includeMax: true)));
       expect(
-          new VersionRange(min: v080, max: v130)
-              .difference(new VersionRange(min: v114)),
-          equals(new VersionRange(min: v080, max: v114, includeMax: true)));
+          VersionRange(min: v080, max: v130)
+              .difference(VersionRange(min: v114)),
+          equals(VersionRange(min: v080, max: v114, includeMax: true)));
       expect(
-          new VersionRange(min: v080, max: v130).difference(
-              new VersionRange(min: v114, max: v140, includeMin: true)),
-          equals(new VersionRange(
+          VersionRange(min: v080, max: v130)
+              .difference(VersionRange(min: v114, max: v140, includeMin: true)),
+          equals(VersionRange(
               min: v080, max: v114, alwaysIncludeMaxPreRelease: true)));
       expect(
-          new VersionRange(min: v080, max: v130, includeMax: true).difference(
-              new VersionRange(min: v130, max: v140, includeMin: true)),
-          equals(new VersionRange(
+          VersionRange(min: v080, max: v130, includeMax: true)
+              .difference(VersionRange(min: v130, max: v140, includeMin: true)),
+          equals(VersionRange(
               min: v080, max: v130, alwaysIncludeMaxPreRelease: true)));
       expect(
-          new VersionRange(min: v080, max: v130, includeMin: true)
-              .difference(new VersionRange(min: v080, max: v130)),
+          VersionRange(min: v080, max: v130, includeMin: true)
+              .difference(VersionRange(min: v080, max: v130)),
           equals(v080));
     });
 
     test("with a range in the middle cuts the range in half", () {
       expect(
-          new VersionRange(min: v003, max: v130)
-              .difference(new VersionRange(min: v072, max: v114)),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v072, includeMax: true),
-            new VersionConstraint.parse(">=1.1.4-0 <1.3.0")
+          VersionRange(min: v003, max: v130)
+              .difference(VersionRange(min: v072, max: v114)),
+          equals(VersionConstraint.unionOf([
+            VersionRange(min: v003, max: v072, includeMax: true),
+            VersionConstraint.parse(">=1.1.4-0 <1.3.0")
           ])));
     });
 
     test("with a totally covering range returns empty", () {
       expect(
-          new VersionRange(min: v114, max: v200)
-              .difference(new VersionRange(min: v072, max: v300)),
+          VersionRange(min: v114, max: v200)
+              .difference(VersionRange(min: v072, max: v300)),
           isEmpty);
       expect(
-          new VersionRange(min: v003, max: v114)
-              .difference(new VersionRange(min: v003, max: v114)),
+          VersionRange(min: v003, max: v114)
+              .difference(VersionRange(min: v003, max: v114)),
           isEmpty);
       expect(
-          new VersionRange(
-                  min: v003, max: v114, includeMin: true, includeMax: true)
-              .difference(new VersionRange(
+          VersionRange(min: v003, max: v114, includeMin: true, includeMax: true)
+              .difference(VersionRange(
                   min: v003, max: v114, includeMin: true, includeMax: true)),
           isEmpty);
     });
@@ -823,55 +788,54 @@
         "with a version union that doesn't cover the range, returns the "
         "original", () {
       expect(
-          new VersionRange(min: v114, max: v140)
-              .difference(new VersionConstraint.unionOf([v010, v200])),
-          equals(new VersionRange(min: v114, max: v140)));
+          VersionRange(min: v114, max: v140)
+              .difference(VersionConstraint.unionOf([v010, v200])),
+          equals(VersionRange(min: v114, max: v140)));
     });
 
     test("with a version union that intersects the ends, chops them off", () {
       expect(
-          new VersionRange(min: v114, max: v140).difference(
-              new VersionConstraint.unionOf([
-            new VersionRange(min: v080, max: v123),
-            new VersionRange(min: v130, max: v200)
+          VersionRange(min: v114, max: v140).difference(
+              VersionConstraint.unionOf([
+            VersionRange(min: v080, max: v123),
+            VersionRange(min: v130, max: v200)
           ])),
-          equals(new VersionConstraint.parse(">=1.2.3-0 <=1.3.0")));
+          equals(VersionConstraint.parse(">=1.2.3-0 <=1.3.0")));
     });
 
     test("with a version union that intersects the middle, chops it up", () {
       expect(
-          new VersionRange(min: v114, max: v140)
-              .difference(new VersionConstraint.unionOf([v123, v124, v130])),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(
+          VersionRange(min: v114, max: v140)
+              .difference(VersionConstraint.unionOf([v123, v124, v130])),
+          equals(VersionConstraint.unionOf([
+            VersionRange(
                 min: v114, max: v123, alwaysIncludeMaxPreRelease: true),
-            new VersionRange(
+            VersionRange(
                 min: v123, max: v124, alwaysIncludeMaxPreRelease: true),
-            new VersionRange(
+            VersionRange(
                 min: v124, max: v130, alwaysIncludeMaxPreRelease: true),
-            new VersionRange(min: v130, max: v140)
+            VersionRange(min: v130, max: v140)
           ])));
     });
 
     test("with a version union that covers the whole range, returns empty", () {
       expect(
-          new VersionRange(min: v114, max: v140).difference(
-              new VersionConstraint.unionOf(
-                  [v003, new VersionRange(min: v010)])),
+          VersionRange(min: v114, max: v140).difference(
+              VersionConstraint.unionOf([v003, VersionRange(min: v010)])),
           equals(VersionConstraint.empty));
     });
 
     test("with a range with a pre-release min, returns the original", () {
       expect(
-          new VersionRange(max: v200)
-              .difference(new VersionConstraint.parse(">=2.0.0-dev")),
-          equals(new VersionRange(max: v200)));
+          VersionRange(max: v200)
+              .difference(VersionConstraint.parse(">=2.0.0-dev")),
+          equals(VersionRange(max: v200)));
     });
 
     test("with a range with a pre-release max, returns null", () {
       expect(
-          new VersionRange(max: v200)
-              .difference(new VersionConstraint.parse("<2.0.0-dev")),
+          VersionRange(max: v200)
+              .difference(VersionConstraint.parse("<2.0.0-dev")),
           equals(VersionConstraint.empty));
     });
 
@@ -881,16 +845,16 @@
             () {
           expect(
               includeMaxPreReleaseRange
-                  .difference(new VersionConstraint.parse("<1.0.0")),
-              equals(new VersionRange(
-                  min: new Version.parse("1.0.0-0"),
+                  .difference(VersionConstraint.parse("<1.0.0")),
+              equals(VersionRange(
+                  min: Version.parse("1.0.0-0"),
                   max: v200,
                   includeMin: true,
                   alwaysIncludeMaxPreRelease: true)));
           expect(
               includeMaxPreReleaseRange
-                  .difference(new VersionConstraint.parse("<2.0.0")),
-              equals(new VersionRange(
+                  .difference(VersionConstraint.parse("<2.0.0")),
+              equals(VersionRange(
                   min: v200.firstPreRelease,
                   max: v200,
                   includeMin: true,
@@ -900,22 +864,22 @@
               equals(VersionConstraint.empty));
           expect(
               includeMaxPreReleaseRange
-                  .difference(new VersionConstraint.parse("<3.0.0")),
+                  .difference(VersionConstraint.parse("<3.0.0")),
               equals(VersionConstraint.empty));
         });
 
         test("with a range with a pre-release min, adjusts the max", () {
           expect(
               includeMaxPreReleaseRange
-                  .difference(new VersionConstraint.parse(">=2.0.0-dev")),
-              equals(new VersionConstraint.parse("<2.0.0-dev")));
+                  .difference(VersionConstraint.parse(">=2.0.0-dev")),
+              equals(VersionConstraint.parse("<2.0.0-dev")));
         });
 
         test("with a range with a pre-release max, adjusts the min", () {
           expect(
               includeMaxPreReleaseRange
-                  .difference(new VersionConstraint.parse("<2.0.0-dev")),
-              equals(new VersionConstraint.parse(">=2.0.0-dev <2.0.0")));
+                  .difference(VersionConstraint.parse("<2.0.0-dev")),
+              equals(VersionConstraint.parse(">=2.0.0-dev <2.0.0")));
         });
       });
 
@@ -923,29 +887,27 @@
         group("doesn't create a pre-release minimum", () {
           test("when cutting off the bottom", () {
             expect(
-                new VersionConstraint.parse("<3.0.0")
+                VersionConstraint.parse("<3.0.0")
                     .difference(includeMaxPreReleaseRange),
-                equals(
-                    new VersionRange(min: v200, max: v300, includeMin: true)));
+                equals(VersionRange(min: v200, max: v300, includeMin: true)));
           });
 
           test("with splitting down the middle", () {
             expect(
-                new VersionConstraint.parse("<4.0.0").difference(
-                    new VersionRange(
-                        min: v200,
-                        max: v300,
-                        includeMin: true,
-                        alwaysIncludeMaxPreRelease: true)),
-                equals(new VersionConstraint.unionOf([
-                  new VersionRange(max: v200, alwaysIncludeMaxPreRelease: true),
-                  new VersionConstraint.parse(">=3.0.0 <4.0.0")
+                VersionConstraint.parse("<4.0.0").difference(VersionRange(
+                    min: v200,
+                    max: v300,
+                    includeMin: true,
+                    alwaysIncludeMaxPreRelease: true)),
+                equals(VersionConstraint.unionOf([
+                  VersionRange(max: v200, alwaysIncludeMaxPreRelease: true),
+                  VersionConstraint.parse(">=3.0.0 <4.0.0")
                 ])));
           });
 
           test("can leave a single version", () {
             expect(
-                new VersionConstraint.parse("<=2.0.0")
+                VersionConstraint.parse("<=2.0.0")
                     .difference(includeMaxPreReleaseRange),
                 equals(v200));
           });
@@ -955,54 +917,54 @@
   });
 
   test('isEmpty', () {
-    expect(new VersionRange().isEmpty, isFalse);
-    expect(new VersionRange(min: v123, max: v124).isEmpty, isFalse);
+    expect(VersionRange().isEmpty, isFalse);
+    expect(VersionRange(min: v123, max: v124).isEmpty, isFalse);
   });
 
   group('compareTo()', () {
     test("orders by minimum first", () {
-      _expectComparesSmaller(new VersionRange(min: v003, max: v080),
-          new VersionRange(min: v010, max: v072));
-      _expectComparesSmaller(new VersionRange(min: v003, max: v080),
-          new VersionRange(min: v010, max: v080));
-      _expectComparesSmaller(new VersionRange(min: v003, max: v080),
-          new VersionRange(min: v010, max: v114));
+      _expectComparesSmaller(VersionRange(min: v003, max: v080),
+          VersionRange(min: v010, max: v072));
+      _expectComparesSmaller(VersionRange(min: v003, max: v080),
+          VersionRange(min: v010, max: v080));
+      _expectComparesSmaller(VersionRange(min: v003, max: v080),
+          VersionRange(min: v010, max: v114));
     });
 
     test("orders by maximum second", () {
-      _expectComparesSmaller(new VersionRange(min: v003, max: v010),
-          new VersionRange(min: v003, max: v072));
+      _expectComparesSmaller(VersionRange(min: v003, max: v010),
+          VersionRange(min: v003, max: v072));
     });
 
     test("includeMin comes before !includeMin", () {
       _expectComparesSmaller(
-          new VersionRange(min: v003, max: v080, includeMin: true),
-          new VersionRange(min: v003, max: v080, includeMin: false));
+          VersionRange(min: v003, max: v080, includeMin: true),
+          VersionRange(min: v003, max: v080, includeMin: false));
     });
 
     test("includeMax comes after !includeMax", () {
       _expectComparesSmaller(
-          new VersionRange(min: v003, max: v080, includeMax: false),
-          new VersionRange(min: v003, max: v080, includeMax: true));
+          VersionRange(min: v003, max: v080, includeMax: false),
+          VersionRange(min: v003, max: v080, includeMax: true));
     });
 
     test("includeMaxPreRelease comes after !includeMaxPreRelease", () {
       _expectComparesSmaller(
-          new VersionRange(max: v200), includeMaxPreReleaseRange);
+          VersionRange(max: v200), includeMaxPreReleaseRange);
     });
 
     test("no minimum comes before small minimum", () {
       _expectComparesSmaller(
-          new VersionRange(max: v010), new VersionRange(min: v003, max: v010));
-      _expectComparesSmaller(new VersionRange(max: v010, includeMin: true),
-          new VersionRange(min: v003, max: v010));
+          VersionRange(max: v010), VersionRange(min: v003, max: v010));
+      _expectComparesSmaller(VersionRange(max: v010, includeMin: true),
+          VersionRange(min: v003, max: v010));
     });
 
     test("no maximium comes after large maximum", () {
       _expectComparesSmaller(
-          new VersionRange(min: v003, max: v300), new VersionRange(min: v003));
-      _expectComparesSmaller(new VersionRange(min: v003, max: v300),
-          new VersionRange(min: v003, includeMax: true));
+          VersionRange(min: v003, max: v300), VersionRange(min: v003));
+      _expectComparesSmaller(VersionRange(min: v003, max: v300),
+          VersionRange(min: v003, includeMax: true));
     });
   });
 }
diff --git a/pkgs/pub_semver/test/version_test.dart b/pkgs/pub_semver/test/version_test.dart
index 448435a..634148b 100644
--- a/pkgs/pub_semver/test/version_test.dart
+++ b/pkgs/pub_semver/test/version_test.dart
@@ -8,7 +8,7 @@
 
 import 'utils.dart';
 
-main() {
+void main() {
   test('none', () {
     expect(Version.none.toString(), equals('0.0.0'));
   });
@@ -29,8 +29,8 @@
     // appears in the list.
     for (var i = 0; i < versions.length; i++) {
       for (var j = 0; j < versions.length; j++) {
-        var a = new Version.parse(versions[i]);
-        var b = new Version.parse(versions[j]);
+        var a = Version.parse(versions[i]);
+        var b = Version.parse(versions[j]);
         expect(Version.prioritize(a, b), equals(i.compareTo(j)));
       }
     }
@@ -52,8 +52,8 @@
     // appears in the list.
     for (var i = 0; i < versions.length; i++) {
       for (var j = 0; j < versions.length; j++) {
-        var a = new Version.parse(versions[i]);
-        var b = new Version.parse(versions[j]);
+        var a = Version.parse(versions[i]);
+        var b = Version.parse(versions[j]);
         expect(Version.antiprioritize(a, b), equals(i.compareTo(j)));
       }
     }
@@ -61,9 +61,9 @@
 
   group('constructor', () {
     test('throws on negative numbers', () {
-      expect(() => new Version(-1, 1, 1), throwsArgumentError);
-      expect(() => new Version(1, -1, 1), throwsArgumentError);
-      expect(() => new Version(1, 1, -1), throwsArgumentError);
+      expect(() => Version(-1, 1, 1), throwsArgumentError);
+      expect(() => Version(1, -1, 1), throwsArgumentError);
+      expect(() => Version(1, 1, -1), throwsArgumentError);
     });
   });
 
@@ -93,8 +93,8 @@
       // appears in the list.
       for (var i = 0; i < versions.length; i++) {
         for (var j = 0; j < versions.length; j++) {
-          var a = new Version.parse(versions[i]);
-          var b = new Version.parse(versions[j]);
+          var a = Version.parse(versions[i]);
+          var b = Version.parse(versions[j]);
           expect(a.compareTo(b), equals(i.compareTo(j)));
         }
       }
@@ -103,8 +103,8 @@
     test('operators', () {
       for (var i = 0; i < versions.length; i++) {
         for (var j = 0; j < versions.length; j++) {
-          var a = new Version.parse(versions[i]);
-          var b = new Version.parse(versions[j]);
+          var a = Version.parse(versions[i]);
+          var b = Version.parse(versions[j]);
           expect(a < b, equals(i < j));
           expect(a > b, equals(i > j));
           expect(a <= b, equals(i <= j));
@@ -116,13 +116,11 @@
     });
 
     test('equality', () {
-      expect(new Version.parse('01.2.3'), equals(new Version.parse('1.2.3')));
-      expect(new Version.parse('1.02.3'), equals(new Version.parse('1.2.3')));
-      expect(new Version.parse('1.2.03'), equals(new Version.parse('1.2.3')));
-      expect(
-          new Version.parse('1.2.3-01'), equals(new Version.parse('1.2.3-1')));
-      expect(
-          new Version.parse('1.2.3+01'), equals(new Version.parse('1.2.3+1')));
+      expect(Version.parse('01.2.3'), equals(Version.parse('1.2.3')));
+      expect(Version.parse('1.02.3'), equals(Version.parse('1.2.3')));
+      expect(Version.parse('1.2.03'), equals(Version.parse('1.2.3')));
+      expect(Version.parse('1.2.3-01'), equals(Version.parse('1.2.3-1')));
+      expect(Version.parse('1.2.3+01'), equals(Version.parse('1.2.3+1')));
     });
   });
 
@@ -131,17 +129,17 @@
     expect(
         v123,
         doesNotAllow(
-            new Version.parse('2.2.3'),
-            new Version.parse('1.3.3'),
-            new Version.parse('1.2.4'),
-            new Version.parse('1.2.3-dev'),
-            new Version.parse('1.2.3+build')));
+            Version.parse('2.2.3'),
+            Version.parse('1.3.3'),
+            Version.parse('1.2.4'),
+            Version.parse('1.2.3-dev'),
+            Version.parse('1.2.3+build')));
   });
 
   test('allowsAll()', () {
     expect(v123.allowsAll(v123), isTrue);
     expect(v123.allowsAll(v003), isFalse);
-    expect(v123.allowsAll(new VersionRange(min: v114, max: v124)), isFalse);
+    expect(v123.allowsAll(VersionRange(min: v114, max: v124)), isFalse);
     expect(v123.allowsAll(VersionConstraint.any), isFalse);
     expect(v123.allowsAll(VersionConstraint.empty), isTrue);
   });
@@ -149,7 +147,7 @@
   test('allowsAny()', () {
     expect(v123.allowsAny(v123), isTrue);
     expect(v123.allowsAny(v003), isFalse);
-    expect(v123.allowsAny(new VersionRange(min: v114, max: v124)), isTrue);
+    expect(v123.allowsAny(VersionRange(min: v114, max: v124)), isTrue);
     expect(v123.allowsAny(VersionConstraint.any), isTrue);
     expect(v123.allowsAny(VersionConstraint.empty), isFalse);
   });
@@ -162,12 +160,10 @@
     expect(v123.intersect(v114).isEmpty, isTrue);
 
     // Intersecting a range returns the version if the range allows it.
-    expect(
-        v123.intersect(new VersionRange(min: v114, max: v124)), equals(v123));
+    expect(v123.intersect(VersionRange(min: v114, max: v124)), equals(v123));
 
     // Intersecting a range allows no versions if the range doesn't allow it.
-    expect(
-        v114.intersect(new VersionRange(min: v123, max: v124)).isEmpty, isTrue);
+    expect(v114.intersect(VersionRange(min: v123, max: v124)).isEmpty, isTrue);
   });
 
   group('union()', () {
@@ -185,27 +181,27 @@
     });
 
     test("with a range returns the range if it contains the version", () {
-      var range = new VersionRange(min: v114, max: v124);
+      var range = VersionRange(min: v114, max: v124);
       expect(v123.union(range), equals(range));
     });
 
     test("with a range with the version on the edge, expands the range", () {
       expect(
-          v124.union(new VersionRange(
+          v124.union(VersionRange(
               min: v114, max: v124, alwaysIncludeMaxPreRelease: true)),
-          equals(new VersionRange(min: v114, max: v124, includeMax: true)));
+          equals(VersionRange(min: v114, max: v124, includeMax: true)));
       expect(
-          v124.firstPreRelease.union(new VersionRange(min: v114, max: v124)),
-          equals(new VersionRange(
+          v124.firstPreRelease.union(VersionRange(min: v114, max: v124)),
+          equals(VersionRange(
               min: v114, max: v124.firstPreRelease, includeMax: true)));
-      expect(v114.union(new VersionRange(min: v114, max: v124)),
-          equals(new VersionRange(min: v114, max: v124, includeMin: true)));
+      expect(v114.union(VersionRange(min: v114, max: v124)),
+          equals(VersionRange(min: v114, max: v124, includeMin: true)));
     });
 
     test(
         "with a range allows both the range and the version if the range "
         "doesn't contain the version", () {
-      var result = v123.union(new VersionRange(min: v003, max: v114));
+      var result = v123.union(VersionRange(min: v003, max: v114));
       expect(result, allows(v123));
       expect(result, allows(v010));
     });
@@ -222,13 +218,12 @@
 
     test("returns an empty constraint with a range that contains the version",
         () {
-      expect(v123.difference(new VersionRange(min: v114, max: v124)), isEmpty);
+      expect(v123.difference(VersionRange(min: v114, max: v124)), isEmpty);
     });
 
     test("returns the version constraint with a range that doesn't contain it",
         () {
-      expect(v123.difference(new VersionRange(min: v140, max: v300)),
-          equals(v123));
+      expect(v123.difference(VersionRange(min: v140, max: v300)), equals(v123));
     });
   });
 
@@ -242,13 +237,13 @@
     expect(v200.nextMajor, equals(v300));
 
     // Ignores pre-release if not on a major version.
-    expect(new Version.parse('1.2.3-dev').nextMajor, equals(v200));
+    expect(Version.parse('1.2.3-dev').nextMajor, equals(v200));
 
     // Just removes it if on a major version.
-    expect(new Version.parse('2.0.0-dev').nextMajor, equals(v200));
+    expect(Version.parse('2.0.0-dev').nextMajor, equals(v200));
 
     // Strips build suffix.
-    expect(new Version.parse('1.2.3+patch').nextMajor, equals(v200));
+    expect(Version.parse('1.2.3+patch').nextMajor, equals(v200));
   });
 
   test('nextMinor', () {
@@ -256,13 +251,13 @@
     expect(v130.nextMinor, equals(v140));
 
     // Ignores pre-release if not on a minor version.
-    expect(new Version.parse('1.2.3-dev').nextMinor, equals(v130));
+    expect(Version.parse('1.2.3-dev').nextMinor, equals(v130));
 
     // Just removes it if on a minor version.
-    expect(new Version.parse('1.3.0-dev').nextMinor, equals(v130));
+    expect(Version.parse('1.3.0-dev').nextMinor, equals(v130));
 
     // Strips build suffix.
-    expect(new Version.parse('1.2.3+patch').nextMinor, equals(v130));
+    expect(Version.parse('1.2.3+patch').nextMinor, equals(v130));
   });
 
   test('nextPatch', () {
@@ -270,10 +265,10 @@
     expect(v200.nextPatch, equals(v201));
 
     // Just removes pre-release version if present.
-    expect(new Version.parse('1.2.4-dev').nextPatch, equals(v124));
+    expect(Version.parse('1.2.4-dev').nextPatch, equals(v124));
 
     // Strips build suffix.
-    expect(new Version.parse('1.2.3+patch').nextPatch, equals(v124));
+    expect(Version.parse('1.2.3+patch').nextPatch, equals(v124));
   });
 
   test('nextBreaking', () {
@@ -282,56 +277,56 @@
     expect(v003.nextBreaking, equals(v010));
 
     // Removes pre-release version if present.
-    expect(new Version.parse('1.2.3-dev').nextBreaking, equals(v200));
+    expect(Version.parse('1.2.3-dev').nextBreaking, equals(v200));
 
     // Strips build suffix.
-    expect(new Version.parse('1.2.3+patch').nextBreaking, equals(v200));
+    expect(Version.parse('1.2.3+patch').nextBreaking, equals(v200));
   });
 
   test('parse()', () {
-    expect(new Version.parse('0.0.0'), equals(new Version(0, 0, 0)));
-    expect(new Version.parse('12.34.56'), equals(new Version(12, 34, 56)));
+    expect(Version.parse('0.0.0'), equals(Version(0, 0, 0)));
+    expect(Version.parse('12.34.56'), equals(Version(12, 34, 56)));
 
-    expect(new Version.parse('1.2.3-alpha.1'),
-        equals(new Version(1, 2, 3, pre: 'alpha.1')));
-    expect(new Version.parse('1.2.3-x.7.z-92'),
-        equals(new Version(1, 2, 3, pre: 'x.7.z-92')));
+    expect(Version.parse('1.2.3-alpha.1'),
+        equals(Version(1, 2, 3, pre: 'alpha.1')));
+    expect(Version.parse('1.2.3-x.7.z-92'),
+        equals(Version(1, 2, 3, pre: 'x.7.z-92')));
 
-    expect(new Version.parse('1.2.3+build.1'),
-        equals(new Version(1, 2, 3, build: 'build.1')));
-    expect(new Version.parse('1.2.3+x.7.z-92'),
-        equals(new Version(1, 2, 3, build: 'x.7.z-92')));
+    expect(Version.parse('1.2.3+build.1'),
+        equals(Version(1, 2, 3, build: 'build.1')));
+    expect(Version.parse('1.2.3+x.7.z-92'),
+        equals(Version(1, 2, 3, build: 'x.7.z-92')));
 
-    expect(new Version.parse('1.0.0-rc-1+build-1'),
-        equals(new Version(1, 0, 0, pre: 'rc-1', build: 'build-1')));
+    expect(Version.parse('1.0.0-rc-1+build-1'),
+        equals(Version(1, 0, 0, pre: 'rc-1', build: 'build-1')));
 
-    expect(() => new Version.parse('1.0'), throwsFormatException);
-    expect(() => new Version.parse('1.2.3.4'), throwsFormatException);
-    expect(() => new Version.parse('1234'), throwsFormatException);
-    expect(() => new Version.parse('-2.3.4'), throwsFormatException);
-    expect(() => new Version.parse('1.3-pre'), throwsFormatException);
-    expect(() => new Version.parse('1.3+build'), throwsFormatException);
-    expect(() => new Version.parse('1.3+bu?!3ild'), throwsFormatException);
+    expect(() => Version.parse('1.0'), throwsFormatException);
+    expect(() => Version.parse('1.2.3.4'), throwsFormatException);
+    expect(() => Version.parse('1234'), throwsFormatException);
+    expect(() => Version.parse('-2.3.4'), throwsFormatException);
+    expect(() => Version.parse('1.3-pre'), throwsFormatException);
+    expect(() => Version.parse('1.3+build'), throwsFormatException);
+    expect(() => Version.parse('1.3+bu?!3ild'), throwsFormatException);
   });
 
   group('toString()', () {
     test('returns the version string', () {
-      expect(new Version(0, 0, 0).toString(), equals('0.0.0'));
-      expect(new Version(12, 34, 56).toString(), equals('12.34.56'));
+      expect(Version(0, 0, 0).toString(), equals('0.0.0'));
+      expect(Version(12, 34, 56).toString(), equals('12.34.56'));
 
-      expect(new Version(1, 2, 3, pre: 'alpha.1').toString(),
-          equals('1.2.3-alpha.1'));
-      expect(new Version(1, 2, 3, pre: 'x.7.z-92').toString(),
+      expect(
+          Version(1, 2, 3, pre: 'alpha.1').toString(), equals('1.2.3-alpha.1'));
+      expect(Version(1, 2, 3, pre: 'x.7.z-92').toString(),
           equals('1.2.3-x.7.z-92'));
 
-      expect(new Version(1, 2, 3, build: 'build.1').toString(),
+      expect(Version(1, 2, 3, build: 'build.1').toString(),
           equals('1.2.3+build.1'));
-      expect(new Version(1, 2, 3, pre: 'pre', build: 'bui').toString(),
+      expect(Version(1, 2, 3, pre: 'pre', build: 'bui').toString(),
           equals('1.2.3-pre+bui'));
     });
 
     test('preserves leading zeroes', () {
-      expect(new Version.parse('001.02.0003-01.dev+pre.002').toString(),
+      expect(Version.parse('001.02.0003-01.dev+pre.002').toString(),
           equals('001.02.0003-01.dev+pre.002'));
     });
   });
diff --git a/pkgs/pub_semver/test/version_union_test.dart b/pkgs/pub_semver/test/version_union_test.dart
index f629c83..11a5ecd 100644
--- a/pkgs/pub_semver/test/version_union_test.dart
+++ b/pkgs/pub_semver/test/version_union_test.dart
@@ -8,11 +8,11 @@
 
 import 'utils.dart';
 
-main() {
+void main() {
   group('factory', () {
     test('ignores empty constraints', () {
       expect(
-          new VersionConstraint.unionOf([
+          VersionConstraint.unionOf([
             VersionConstraint.empty,
             VersionConstraint.empty,
             v123,
@@ -21,141 +21,140 @@
           equals(v123));
 
       expect(
-          new VersionConstraint.unionOf(
+          VersionConstraint.unionOf(
               [VersionConstraint.empty, VersionConstraint.empty]),
           isEmpty);
     });
 
     test('returns an empty constraint for an empty list', () {
-      expect(new VersionConstraint.unionOf([]), isEmpty);
+      expect(VersionConstraint.unionOf([]), isEmpty);
     });
 
     test('any constraints override everything', () {
       expect(
-          new VersionConstraint.unionOf([
+          VersionConstraint.unionOf([
             v123,
             VersionConstraint.any,
             v200,
-            new VersionRange(min: v234, max: v250)
+            VersionRange(min: v234, max: v250)
           ]),
           equals(VersionConstraint.any));
     });
 
     test('flattens other unions', () {
       expect(
-          new VersionConstraint.unionOf([
+          VersionConstraint.unionOf([
             v072,
-            new VersionConstraint.unionOf([v123, v124]),
+            VersionConstraint.unionOf([v123, v124]),
             v250
           ]),
-          equals(new VersionConstraint.unionOf([v072, v123, v124, v250])));
+          equals(VersionConstraint.unionOf([v072, v123, v124, v250])));
     });
 
     test('returns a single merged range as-is', () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v080, max: v140),
-            new VersionRange(min: v123, max: v200)
+          VersionConstraint.unionOf([
+            VersionRange(min: v080, max: v140),
+            VersionRange(min: v123, max: v200)
           ]),
-          equals(new VersionRange(min: v080, max: v200)));
+          equals(VersionRange(min: v080, max: v200)));
     });
   });
 
   group('equality', () {
     test("doesn't depend on original order", () {
       expect(
-          new VersionConstraint.unionOf([
+          VersionConstraint.unionOf([
             v250,
-            new VersionRange(min: v201, max: v234),
+            VersionRange(min: v201, max: v234),
             v124,
             v072,
-            new VersionRange(min: v080, max: v114),
+            VersionRange(min: v080, max: v114),
             v123
           ]),
-          equals(new VersionConstraint.unionOf([
+          equals(VersionConstraint.unionOf([
             v072,
-            new VersionRange(min: v080, max: v114),
+            VersionRange(min: v080, max: v114),
             v123,
             v124,
-            new VersionRange(min: v201, max: v234),
+            VersionRange(min: v201, max: v234),
             v250
           ])));
     });
 
     test("merges overlapping ranges", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v072),
-            new VersionRange(min: v010, max: v080),
-            new VersionRange(min: v114, max: v124),
-            new VersionRange(min: v123, max: v130)
+          VersionConstraint.unionOf([
+            VersionRange(min: v003, max: v072),
+            VersionRange(min: v010, max: v080),
+            VersionRange(min: v114, max: v124),
+            VersionRange(min: v123, max: v130)
           ]),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v080),
-            new VersionRange(min: v114, max: v130)
+          equals(VersionConstraint.unionOf([
+            VersionRange(min: v003, max: v080),
+            VersionRange(min: v114, max: v130)
           ])));
     });
 
     test("merges adjacent ranges", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v072, includeMax: true),
-            new VersionRange(min: v072, max: v080),
-            new VersionRange(
+          VersionConstraint.unionOf([
+            VersionRange(min: v003, max: v072, includeMax: true),
+            VersionRange(min: v072, max: v080),
+            VersionRange(
                 min: v114, max: v124, alwaysIncludeMaxPreRelease: true),
-            new VersionRange(min: v124, max: v130, includeMin: true),
-            new VersionRange(
-                min: v130.firstPreRelease, max: v200, includeMin: true)
+            VersionRange(min: v124, max: v130, includeMin: true),
+            VersionRange(min: v130.firstPreRelease, max: v200, includeMin: true)
           ]),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v080),
-            new VersionRange(min: v114, max: v200)
+          equals(VersionConstraint.unionOf([
+            VersionRange(min: v003, max: v080),
+            VersionRange(min: v114, max: v200)
           ])));
     });
 
     test("doesn't merge not-quite-adjacent ranges", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v114, max: v124),
-            new VersionRange(min: v124, max: v130, includeMin: true)
+          VersionConstraint.unionOf([
+            VersionRange(min: v114, max: v124),
+            VersionRange(min: v124, max: v130, includeMin: true)
           ]),
-          isNot(equals(new VersionRange(min: v114, max: v130))));
+          isNot(equals(VersionRange(min: v114, max: v130))));
 
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v072),
-            new VersionRange(min: v072, max: v080)
+          VersionConstraint.unionOf([
+            VersionRange(min: v003, max: v072),
+            VersionRange(min: v072, max: v080)
           ]),
-          isNot(equals(new VersionRange(min: v003, max: v080))));
+          isNot(equals(VersionRange(min: v003, max: v080))));
     });
 
     test("merges version numbers into ranges", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v072),
+          VersionConstraint.unionOf([
+            VersionRange(min: v003, max: v072),
             v010,
-            new VersionRange(min: v114, max: v124),
+            VersionRange(min: v114, max: v124),
             v123
           ]),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v072),
-            new VersionRange(min: v114, max: v124)
+          equals(VersionConstraint.unionOf([
+            VersionRange(min: v003, max: v072),
+            VersionRange(min: v114, max: v124)
           ])));
     });
 
     test("merges adjacent version numbers into ranges", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(
+          VersionConstraint.unionOf([
+            VersionRange(
                 min: v003, max: v072, alwaysIncludeMaxPreRelease: true),
             v072,
             v114,
-            new VersionRange(min: v114, max: v124),
+            VersionRange(min: v114, max: v124),
             v124.firstPreRelease
           ]),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v072, includeMax: true),
-            new VersionRange(
+          equals(VersionConstraint.unionOf([
+            VersionRange(min: v003, max: v072, includeMax: true),
+            VersionRange(
                 min: v114,
                 max: v124.firstPreRelease,
                 includeMin: true,
@@ -165,35 +164,33 @@
 
     test("doesn't merge not-quite-adjacent version numbers into ranges", () {
       expect(
-          new VersionConstraint.unionOf(
-              [new VersionRange(min: v003, max: v072), v072]),
-          isNot(equals(
-              new VersionRange(min: v003, max: v072, includeMax: true))));
+          VersionConstraint.unionOf([VersionRange(min: v003, max: v072), v072]),
+          isNot(equals(VersionRange(min: v003, max: v072, includeMax: true))));
     });
   });
 
   test('isEmpty returns false', () {
     expect(
-        new VersionConstraint.unionOf([
-          new VersionRange(min: v003, max: v080),
-          new VersionRange(min: v123, max: v130),
+        VersionConstraint.unionOf([
+          VersionRange(min: v003, max: v080),
+          VersionRange(min: v123, max: v130),
         ]),
         isNot(isEmpty));
   });
 
   test('isAny returns false', () {
     expect(
-        new VersionConstraint.unionOf([
-          new VersionRange(min: v003, max: v080),
-          new VersionRange(min: v123, max: v130),
+        VersionConstraint.unionOf([
+          VersionRange(min: v003, max: v080),
+          VersionRange(min: v123, max: v130),
         ]).isAny,
         isFalse);
   });
 
   test('allows() allows anything the components allow', () {
-    var union = new VersionConstraint.unionOf([
-      new VersionRange(min: v003, max: v080),
-      new VersionRange(min: v123, max: v130),
+    var union = VersionConstraint.unionOf([
+      VersionRange(min: v003, max: v080),
+      VersionRange(min: v123, max: v130),
       v200
     ]);
 
@@ -206,9 +203,9 @@
 
   group('allowsAll()', () {
     test('for a version, returns true if any component allows the version', () {
-      var union = new VersionConstraint.unionOf([
-        new VersionRange(min: v003, max: v080),
-        new VersionRange(min: v123, max: v130),
+      var union = VersionConstraint.unionOf([
+        VersionRange(min: v003, max: v080),
+        VersionRange(min: v123, max: v130),
         v200
       ]);
 
@@ -222,56 +219,56 @@
     test(
         'for a version range, returns true if any component allows the whole '
         'range', () {
-      var union = new VersionConstraint.unionOf([
-        new VersionRange(min: v003, max: v080),
-        new VersionRange(min: v123, max: v130)
+      var union = VersionConstraint.unionOf([
+        VersionRange(min: v003, max: v080),
+        VersionRange(min: v123, max: v130)
       ]);
 
-      expect(union.allowsAll(new VersionRange(min: v003, max: v080)), isTrue);
-      expect(union.allowsAll(new VersionRange(min: v010, max: v072)), isTrue);
-      expect(union.allowsAll(new VersionRange(min: v010, max: v124)), isFalse);
+      expect(union.allowsAll(VersionRange(min: v003, max: v080)), isTrue);
+      expect(union.allowsAll(VersionRange(min: v010, max: v072)), isTrue);
+      expect(union.allowsAll(VersionRange(min: v010, max: v124)), isFalse);
     });
 
     group('for a union,', () {
-      var union = new VersionConstraint.unionOf([
-        new VersionRange(min: v003, max: v080),
-        new VersionRange(min: v123, max: v130)
+      var union = VersionConstraint.unionOf([
+        VersionRange(min: v003, max: v080),
+        VersionRange(min: v123, max: v130)
       ]);
 
       test('returns true if every constraint matches a different constraint',
           () {
         expect(
-            union.allowsAll(new VersionConstraint.unionOf([
-              new VersionRange(min: v010, max: v072),
-              new VersionRange(min: v124, max: v130)
+            union.allowsAll(VersionConstraint.unionOf([
+              VersionRange(min: v010, max: v072),
+              VersionRange(min: v124, max: v130)
             ])),
             isTrue);
       });
 
       test('returns true if every constraint matches the same constraint', () {
         expect(
-            union.allowsAll(new VersionConstraint.unionOf([
-              new VersionRange(min: v003, max: v010),
-              new VersionRange(min: v072, max: v080)
+            union.allowsAll(VersionConstraint.unionOf([
+              VersionRange(min: v003, max: v010),
+              VersionRange(min: v072, max: v080)
             ])),
             isTrue);
       });
 
       test("returns false if there's an unmatched constraint", () {
         expect(
-            union.allowsAll(new VersionConstraint.unionOf([
-              new VersionRange(min: v010, max: v072),
-              new VersionRange(min: v124, max: v130),
-              new VersionRange(min: v140, max: v200)
+            union.allowsAll(VersionConstraint.unionOf([
+              VersionRange(min: v010, max: v072),
+              VersionRange(min: v124, max: v130),
+              VersionRange(min: v140, max: v200)
             ])),
             isFalse);
       });
 
       test("returns false if a constraint isn't fully matched", () {
         expect(
-            union.allowsAll(new VersionConstraint.unionOf([
-              new VersionRange(min: v010, max: v114),
-              new VersionRange(min: v124, max: v130)
+            union.allowsAll(VersionConstraint.unionOf([
+              VersionRange(min: v010, max: v114),
+              VersionRange(min: v124, max: v130)
             ])),
             isFalse);
       });
@@ -280,9 +277,9 @@
 
   group('allowsAny()', () {
     test('for a version, returns true if any component allows the version', () {
-      var union = new VersionConstraint.unionOf([
-        new VersionRange(min: v003, max: v080),
-        new VersionRange(min: v123, max: v130),
+      var union = VersionConstraint.unionOf([
+        VersionRange(min: v003, max: v080),
+        VersionRange(min: v123, max: v130),
         v200
       ]);
 
@@ -296,38 +293,38 @@
     test(
         'for a version range, returns true if any component allows part of '
         'the range', () {
-      var union = new VersionConstraint.unionOf(
-          [new VersionRange(min: v003, max: v080), v123]);
+      var union =
+          VersionConstraint.unionOf([VersionRange(min: v003, max: v080), v123]);
 
-      expect(union.allowsAny(new VersionRange(min: v010, max: v114)), isTrue);
-      expect(union.allowsAny(new VersionRange(min: v114, max: v124)), isTrue);
-      expect(union.allowsAny(new VersionRange(min: v124, max: v130)), isFalse);
+      expect(union.allowsAny(VersionRange(min: v010, max: v114)), isTrue);
+      expect(union.allowsAny(VersionRange(min: v114, max: v124)), isTrue);
+      expect(union.allowsAny(VersionRange(min: v124, max: v130)), isFalse);
     });
 
     group('for a union,', () {
-      var union = new VersionConstraint.unionOf([
-        new VersionRange(min: v010, max: v080),
-        new VersionRange(min: v123, max: v130)
+      var union = VersionConstraint.unionOf([
+        VersionRange(min: v010, max: v080),
+        VersionRange(min: v123, max: v130)
       ]);
 
       test('returns true if any constraint matches', () {
         expect(
-            union.allowsAny(new VersionConstraint.unionOf(
-                [v072, new VersionRange(min: v200, max: v300)])),
+            union.allowsAny(VersionConstraint.unionOf(
+                [v072, VersionRange(min: v200, max: v300)])),
             isTrue);
 
         expect(
-            union.allowsAny(new VersionConstraint.unionOf(
-                [v003, new VersionRange(min: v124, max: v300)])),
+            union.allowsAny(VersionConstraint.unionOf(
+                [v003, VersionRange(min: v124, max: v300)])),
             isTrue);
       });
 
       test("returns false if no constraint matches", () {
         expect(
-            union.allowsAny(new VersionConstraint.unionOf([
+            union.allowsAny(VersionConstraint.unionOf([
               v003,
-              new VersionRange(min: v130, max: v140),
-              new VersionRange(min: v140, max: v200)
+              VersionRange(min: v130, max: v140),
+              VersionRange(min: v140, max: v200)
             ])),
             isFalse);
       });
@@ -337,83 +334,83 @@
   group("intersect()", () {
     test("with an overlapping version, returns that version", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v010, max: v080),
-            new VersionRange(min: v123, max: v140)
+          VersionConstraint.unionOf([
+            VersionRange(min: v010, max: v080),
+            VersionRange(min: v123, max: v140)
           ]).intersect(v072),
           equals(v072));
     });
 
     test("with a non-overlapping version, returns an empty constraint", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v010, max: v080),
-            new VersionRange(min: v123, max: v140)
+          VersionConstraint.unionOf([
+            VersionRange(min: v010, max: v080),
+            VersionRange(min: v123, max: v140)
           ]).intersect(v300),
           isEmpty);
     });
 
     test("with an overlapping range, returns that range", () {
-      var range = new VersionRange(min: v072, max: v080);
+      var range = VersionRange(min: v072, max: v080);
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v010, max: v080),
-            new VersionRange(min: v123, max: v140)
+          VersionConstraint.unionOf([
+            VersionRange(min: v010, max: v080),
+            VersionRange(min: v123, max: v140)
           ]).intersect(range),
           equals(range));
     });
 
     test("with a non-overlapping range, returns an empty constraint", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v010, max: v080),
-            new VersionRange(min: v123, max: v140)
-          ]).intersect(new VersionRange(min: v080, max: v123)),
+          VersionConstraint.unionOf([
+            VersionRange(min: v010, max: v080),
+            VersionRange(min: v123, max: v140)
+          ]).intersect(VersionRange(min: v080, max: v123)),
           isEmpty);
     });
 
     test("with a parially-overlapping range, returns the overlapping parts",
         () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v010, max: v080),
-            new VersionRange(min: v123, max: v140)
-          ]).intersect(new VersionRange(min: v072, max: v130)),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(min: v072, max: v080),
-            new VersionRange(min: v123, max: v130)
+          VersionConstraint.unionOf([
+            VersionRange(min: v010, max: v080),
+            VersionRange(min: v123, max: v140)
+          ]).intersect(VersionRange(min: v072, max: v130)),
+          equals(VersionConstraint.unionOf([
+            VersionRange(min: v072, max: v080),
+            VersionRange(min: v123, max: v130)
           ])));
     });
 
     group("for a union,", () {
-      var union = new VersionConstraint.unionOf([
-        new VersionRange(min: v003, max: v080),
-        new VersionRange(min: v123, max: v130)
+      var union = VersionConstraint.unionOf([
+        VersionRange(min: v003, max: v080),
+        VersionRange(min: v123, max: v130)
       ]);
 
       test("returns the overlapping parts", () {
         expect(
-            union.intersect(new VersionConstraint.unionOf([
+            union.intersect(VersionConstraint.unionOf([
               v010,
-              new VersionRange(min: v072, max: v124),
-              new VersionRange(min: v124, max: v130)
+              VersionRange(min: v072, max: v124),
+              VersionRange(min: v124, max: v130)
             ])),
-            equals(new VersionConstraint.unionOf([
+            equals(VersionConstraint.unionOf([
               v010,
-              new VersionRange(min: v072, max: v080),
-              new VersionRange(min: v123, max: v124),
-              new VersionRange(min: v124, max: v130)
+              VersionRange(min: v072, max: v080),
+              VersionRange(min: v123, max: v124),
+              VersionRange(min: v124, max: v130)
             ])));
       });
 
       test("drops parts that don't match", () {
         expect(
-            union.intersect(new VersionConstraint.unionOf([
+            union.intersect(VersionConstraint.unionOf([
               v003,
-              new VersionRange(min: v072, max: v080),
-              new VersionRange(min: v080, max: v123)
+              VersionRange(min: v072, max: v080),
+              VersionRange(min: v080, max: v123)
             ])),
-            equals(new VersionRange(min: v072, max: v080)));
+            equals(VersionRange(min: v072, max: v080)));
       });
     });
   });
@@ -421,67 +418,65 @@
   group("difference()", () {
     test("ignores ranges that don't intersect", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v072, max: v080),
-            new VersionRange(min: v123, max: v130)
-          ]).difference(new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v010),
-            new VersionRange(min: v080, max: v123),
-            new VersionRange(min: v140)
+          VersionConstraint.unionOf([
+            VersionRange(min: v072, max: v080),
+            VersionRange(min: v123, max: v130)
+          ]).difference(VersionConstraint.unionOf([
+            VersionRange(min: v003, max: v010),
+            VersionRange(min: v080, max: v123),
+            VersionRange(min: v140)
           ])),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(min: v072, max: v080),
-            new VersionRange(min: v123, max: v130)
+          equals(VersionConstraint.unionOf([
+            VersionRange(min: v072, max: v080),
+            VersionRange(min: v123, max: v130)
           ])));
     });
 
     test("removes overlapping portions", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v010, max: v080),
-            new VersionRange(min: v123, max: v130)
-          ]).difference(new VersionConstraint.unionOf([
-            new VersionRange(min: v003, max: v072),
-            new VersionRange(min: v124)
-          ])),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(
+          VersionConstraint.unionOf([
+            VersionRange(min: v010, max: v080),
+            VersionRange(min: v123, max: v130)
+          ]).difference(VersionConstraint.unionOf(
+              [VersionRange(min: v003, max: v072), VersionRange(min: v124)])),
+          equals(VersionConstraint.unionOf([
+            VersionRange(
                 min: v072.firstPreRelease, max: v080, includeMin: true),
-            new VersionRange(min: v123, max: v124, includeMax: true)
+            VersionRange(min: v123, max: v124, includeMax: true)
           ])));
     });
 
     test("removes multiple portions from the same range", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v010, max: v114),
-            new VersionRange(min: v130, max: v200)
-          ]).difference(new VersionConstraint.unionOf([v072, v080])),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(
+          VersionConstraint.unionOf([
+            VersionRange(min: v010, max: v114),
+            VersionRange(min: v130, max: v200)
+          ]).difference(VersionConstraint.unionOf([v072, v080])),
+          equals(VersionConstraint.unionOf([
+            VersionRange(
                 min: v010, max: v072, alwaysIncludeMaxPreRelease: true),
-            new VersionRange(
+            VersionRange(
                 min: v072, max: v080, alwaysIncludeMaxPreRelease: true),
-            new VersionRange(min: v080, max: v114),
-            new VersionRange(min: v130, max: v200)
+            VersionRange(min: v080, max: v114),
+            VersionRange(min: v130, max: v200)
           ])));
     });
 
     test("removes the same range from multiple ranges", () {
       expect(
-          new VersionConstraint.unionOf([
-            new VersionRange(min: v010, max: v072),
-            new VersionRange(min: v080, max: v123),
-            new VersionRange(min: v124, max: v130),
-            new VersionRange(min: v200, max: v234),
-            new VersionRange(min: v250, max: v300)
-          ]).difference(new VersionRange(min: v114, max: v201)),
-          equals(new VersionConstraint.unionOf([
-            new VersionRange(min: v010, max: v072),
-            new VersionRange(min: v080, max: v114, includeMax: true),
-            new VersionRange(
+          VersionConstraint.unionOf([
+            VersionRange(min: v010, max: v072),
+            VersionRange(min: v080, max: v123),
+            VersionRange(min: v124, max: v130),
+            VersionRange(min: v200, max: v234),
+            VersionRange(min: v250, max: v300)
+          ]).difference(VersionRange(min: v114, max: v201)),
+          equals(VersionConstraint.unionOf([
+            VersionRange(min: v010, max: v072),
+            VersionRange(min: v080, max: v114, includeMax: true),
+            VersionRange(
                 min: v201.firstPreRelease, max: v234, includeMin: true),
-            new VersionRange(min: v250, max: v300)
+            VersionRange(min: v250, max: v300)
           ])));
     });
   });