Make getKeys, getValues getters (keys, values).

utils/pub/version_solver.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Attempts to resolve a set of version constraints for a package dependency
  * graph and select an appropriate set of best specific versions for all
  * dependent packages. It works iteratively and tries to reach a stable
  * solution where the constraints of all dependencies are met. If it fails to
  * reach a solution after a certain number of iterations, it assumes the
@@ skipping 186 matching lines @@
         enqueue(new UnlockPackage(depender));
         return true;
       }
     }
 
     return dependency.dependers.map(getDependency).some((subdependency) =>
         tryUnlockDepender(subdependency, seen));
   }
 
   List<PackageId> buildResults() {
-    return _packages.getValues().filter((dep) => dep.isDependedOn).map((dep) {
+    return _packages.values.filter((dep) => dep.isDependedOn).map((dep) {
       var description = dep.description;
 
       // If the lockfile contains a fully-resolved description for the package,
       // use that. This allows e.g. Git to ensure that the same commit is used.
       var lockedPackage = lockFile.packages[dep.name];
       if (lockedPackage != null && lockedPackage.version == dep.version &&
           lockedPackage.source.name == dep.source.name &&
           dep.source.descriptionsEqual(
               description, lockedPackage.description)) {
         description = lockedPackage.description;
@@ skipping 53 matching lines @@
     solver.setVersion(package, version);
 
     // The dependencies between the old and new version may be different. Walk
     // them both and update any constraints that differ between the two.
     return Futures.wait([
         getDependencyRefs(solver, oldVersion),
         getDependencyRefs(solver, version)]).transform((list) {
       var oldDependencyRefs = list[0];
       var newDependencyRefs = list[1];
 
-      for (var oldRef in oldDependencyRefs.getValues()) {
+      for (var oldRef in oldDependencyRefs.values) {
         if (newDependencyRefs.containsKey(oldRef.name)) {
           // The dependency is in both versions of this package, but its
           // constraint may have changed.
           var newRef = newDependencyRefs.remove(oldRef.name);
           solver.enqueue(new AddConstraint(package, newRef));
         } else {
           // The dependency is not in the new version of the package, so just
           // remove its constraint.
           solver.enqueue(new RemoveConstraint(package, oldRef.name));
         }
       }
 
       // Everything that's left is a depdendency that's only in the new
       // version of the package.
-      for (var newRef in newDependencyRefs.getValues()) {
+      for (var newRef in newDependencyRefs.values) {
         solver.enqueue(new AddConstraint(package, newRef));
       }
     });
   }
 
   /**
    * Get the dependencies at [version] of the package being changed.
    */
   Future<Map<String, PackageRef>> getDependencyRefs(VersionSolver solver,
       Version version) {
@@ skipping 234 matching lines @@
   bool useLatestVersion = false;
 
   /**
    * Gets whether or not any other packages are currently depending on this
    * one. If `false`, then it means this package is not part of the dependency
    * graph and should be omitted.
    */
   bool get isDependedOn => !_refs.isEmpty;
 
   /** The names of all the packages that depend on this dependency. */
-  Collection<String> get dependers => _refs.getKeys();
+  Collection<String> get dependers => _refs.keys;
 
   /**
    * Gets the overall constraint that all packages are placing on this one.
    * If no packages have a constraint on this one (which can happen when this
    * package is in the process of being added to the graph), returns `null`.
    */
   VersionConstraint get constraint {
     if (_refs.isEmpty) return null;
     return new VersionConstraint.intersect(
-        _refs.getValues().map((ref) => ref.constraint));
+        _refs.values.map((ref) => ref.constraint));
   }
 
   /// The source of this dependency's package.
   Source get source {
      var canonical = _canonicalRef();
      if (canonical == null) return null;
      return canonical.source;
   }
 
   /// The description of this dependency's package.
   get description {
      var canonical = _canonicalRef();
      if (canonical == null) return null;
      return canonical.description;
   }
 
   /// Return the PackageRef that has the canonical source and description for
   /// this package. If any dependency requires that this package come from a
   /// [RootSource], that will be used; otherwise, it will be the source and
   /// description that all dependencies agree upon.
   PackageRef _canonicalRef() {
     if (_refs.isEmpty) return null;
-    var refs = _refs.getValues();
+    var refs = _refs.values;
     for (var ref in refs) {
       if (ref is RootSource) return ref;
     }
     return refs[0];
   }
 
   Dependency(this.name)
       : _refs = <String, PackageRef>{};
 
   Dependency._clone(Dependency other)
@@ skipping 23 matching lines @@
     }
 
     _refs[package] = ref;
   }
 
   /// Returns a PackageRef whose source and description any new constraints are
   /// required to match. Returns null if there are no requirements on new
   /// constraints.
   PackageRef _requiredRef() {
     if (_refs.isEmpty) return null;
-    var refs = _refs.getValues();
+    var refs = _refs.values;
     var first = refs[0];
     if (refs.length == 1) {
       if (first.source is RootSource) return null;
       return first;
     }
     return refs[1];
   }
 
   /**
    * Removes the constraint from [package] onto this.
@@ skipping 85 matching lines @@
   final description1;
   final description2;
 
   DescriptionMismatchException(this.package, this.description1,
       this.description2);
 
   // TODO(nweiz): Dump to YAML when that's supported
   String toString() => "Package '$package' has conflicting descriptions "
     "'${JSON.stringify(description1)}' and '${JSON.stringify(description2)}'";
 }