Make getKeys, getValues getters (keys, values).

lib/compiler/implementation/types/concrete_types_inferrer.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.
 
 class CancelTypeInferenceException {
   final Node node;
   final String reason;
 
   CancelTypeInferenceException(this.node, this.reason);
 }
@@ skipping 195 matching lines @@
 
   ConcreteTypeCartesianProductIterator(this.baseTypeOfThis,
       Map<Element, ConcreteType> concreteTypes) :
     this.concreteTypes = concreteTypes,
     nextValues = new Map<Element, BaseType>(),
     state = new Map<Element, Iterator>() {
     if (concreteTypes.isEmpty) {
       size = 0;
       return;
     }
-    for (final e in concreteTypes.getKeys()) {
+    for (final e in concreteTypes.keys) {
       final baseTypes = concreteTypes[e].baseTypes;
       size *= baseTypes.length;
     }
   }
 
   bool get hasNext {
     return counter < size;
   }
 
   ConcreteTypesEnvironment takeSnapshot() {
     Map<Element, ConcreteType> result = new Map<Element, ConcreteType>();
     nextValues.forEach((k, v) { result[k] = new ConcreteType.singleton(v); });
     return new ConcreteTypesEnvironment.of(result, baseTypeOfThis);
   }
 
   ConcreteTypesEnvironment next() {
     if (!hasNext) throw new NoMoreElementsException();
     Element keyToIncrement = null;
-    for (final key in concreteTypes.getKeys()) {
+    for (final key in concreteTypes.keys) {
       final iterator = state[key];
       if (iterator != null && iterator.hasNext) {
         nextValues[key] = state[key].next();
         break;
       }
       Iterator newIterator = concreteTypes[key].baseTypes.iterator();
       state[key] = newIterator;
       nextValues[key] = newIterator.next();
     }
     counter++;
@@ skipping 64 matching lines @@
         newMap[element] = currentType.union(type);
       }
     });
     return new ConcreteTypesEnvironment.of(newMap, typeOfThis);
   }
 
   bool operator ==(ConcreteTypesEnvironment other) {
     if (other is! ConcreteTypesEnvironment) return false;
     if (typeOfThis != other.typeOfThis) return false;
     if (environment.length != other.environment.length) return false;
-    for (Element key in environment.getKeys()) {
+    for (Element key in environment.keys) {
       if (!other.environment.containsKey(key)
           || (environment[key] != other.environment[key])) {
         return false;
       }
     }
     return true;
   }
 
   int get hashCode {
     int result = (typeOfThis != null) ? typeOfThis.hashCode : 1;
@@ skipping 325 matching lines @@
     final Map<SourceString, Element> leftOverNamedParameters =
         new Map<SourceString, Element>();
     for (;
          !remainingNamedParameters.isEmpty;
          remainingNamedParameters = remainingNamedParameters.tail) {
       final Element namedParameter = remainingNamedParameters.head;
       leftOverNamedParameters[namedParameter.name] = namedParameter;
     }
     // we attach the named arguments to their corresponding named paramaters
     // (we don't use foreach because we want to be able to return early)
-    for (Identifier identifier in argumentsTypes.named.getKeys()) {
+    for (Identifier identifier in argumentsTypes.named.keys) {
       final ConcreteType concreteType = argumentsTypes.named[identifier];
       SourceString source = identifier.source;
       final Element namedParameter = leftOverNamedParameters[source];
       // unexisting or already used named parameter
       if (namedParameter == null) return null;
       result[namedParameter] = concreteType;
       leftOverNamedParameters.remove(source);
     };
     // we use null for each unused named parameter
     // TODO(polux): use default value whenever available
@@ skipping 705 matching lines @@
     Element element = elements[node];
     inferrer.addCaller(element, currentMethod);
     return inferrer.getSendReturnType(element, null,
         analyzeArguments(node.arguments));
   }
 
   void internalError(String reason, {Node node}) {
     inferrer.fail(node, reason);
   }
 }