Big merge from experimental to bleeding edge.

sdk/lib/_internal/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.
 
 part of types;
 
 class CancelTypeInferenceException {
   final Node node;
   final String reason;
 
@@ skipping 153 matching lines @@
     UnionType otherUnion = other;  // cast
     Set<BaseType> newBaseTypes = new Set<BaseType>.from(baseTypes);
     newBaseTypes.addAll(otherUnion.baseTypes);
     return newBaseTypes.length > maxConcreteTypeSize
         ? const UnknownConcreteType()
         : new UnionType(newBaseTypes);
   }
 
   ClassElement getUniqueType() {
     if (baseTypes.length == 1) {
-      BaseType uniqueBaseType = baseTypes.iterator().next();
+      var iterator = baseTypes.iterator;
+      iterator.moveNext();
+      BaseType uniqueBaseType = iterator.current;
       if (uniqueBaseType.isClass()) {
         ClassBaseType uniqueClassType = uniqueBaseType;
         return uniqueClassType.element;
       }
     }
     return null;
   }
 
   String toString() => baseTypes.toString();
 }
 
 /**
  * The cartesian product of concrete types: an iterable of [BaseTypeTuple]s. For
  * instance, the cartesian product of the concrete types [: {A, B} :] and
  * [: {C, D} :] is an itearble whose iterators will yield [: (A, C) :],
  * [: (A, D) :], [: (B, C) :] and finally [: (B, D) :].
  */
 class ConcreteTypeCartesianProduct
-    implements Iterable<ConcreteTypesEnvironment> {
+    extends Iterable<ConcreteTypesEnvironment> {
   final ConcreteTypesInferrer inferrer;
   final BaseType baseTypeOfThis;
   final Map<Element, ConcreteType> concreteTypes;
   ConcreteTypeCartesianProduct(this.inferrer, this.baseTypeOfThis,
                                this.concreteTypes);
-  Iterator iterator() => concreteTypes.isEmpty
-      ? [new ConcreteTypesEnvironment(inferrer, baseTypeOfThis)].iterator()
+  Iterator get iterator => concreteTypes.isEmpty
+      ? [new ConcreteTypesEnvironment(inferrer, baseTypeOfThis)].iterator
       : new ConcreteTypeCartesianProductIterator(inferrer, baseTypeOfThis,
                                                  concreteTypes);
   String toString() {
     List<ConcreteTypesEnvironment> cartesianProduct =
         new List<ConcreteTypesEnvironment>.from(this);
     return cartesianProduct.toString();
   }
 }
 
 /**
  * An helper class for [ConcreteTypeCartesianProduct].
  */
-class ConcreteTypeCartesianProductIterator implements Iterator {
+class ConcreteTypeCartesianProductIterator
+    implements Iterator<ConcreteTypesEnvironment> {
   final ConcreteTypesInferrer inferrer;
   final BaseType baseTypeOfThis;
   final Map<Element, ConcreteType> concreteTypes;
   final Map<Element, BaseType> nextValues;
   final Map<Element, Iterator> state;
   int size = 1;
   int counter = 0;
+  ConcreteTypesEnvironment _current;
 
   ConcreteTypeCartesianProductIterator(this.inferrer, 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.keys) {
       final baseTypes = concreteTypes[e].baseTypes;
       size *= baseTypes.length;
     }
   }
 
-  bool get hasNext {
-    return counter < size;
-  }
+  ConcreteTypesEnvironment get current => _current;
 
   ConcreteTypesEnvironment takeSnapshot() {
     Map<Element, ConcreteType> result = new Map<Element, ConcreteType>();
     nextValues.forEach((k, v) {
       result[k] = inferrer.singletonConcreteType(v);
     });
     return new ConcreteTypesEnvironment.of(inferrer, result, baseTypeOfThis);
   }
 
-  ConcreteTypesEnvironment next() {
-    if (!hasNext) throw new StateError("No more elements");
+  bool moveNext() {
+    if (counter >= size) {
+      _current = null;
+      return false;
+    }
     Element keyToIncrement = null;
     for (final key in concreteTypes.keys) {
       final iterator = state[key];
-      if (iterator != null && iterator.hasNext) {
-        nextValues[key] = state[key].next();
+      if (iterator != null && iterator.moveNext()) {
+        nextValues[key] = state[key].current;
         break;
       }
-      Iterator newIterator = concreteTypes[key].baseTypes.iterator();
+      Iterator newIterator = concreteTypes[key].baseTypes.iterator;
       state[key] = newIterator;
-      nextValues[key] = newIterator.next();
+      newIterator.moveNext();
+      nextValues[key] = newIterator.current;
     }
     counter++;
-    return takeSnapshot();
+    _current = takeSnapshot();
+    return true;
   }
 }
 
 /**
  * [BaseType] Constants.
  */
 class BaseTypes {
   final BaseType intBaseType;
   final BaseType doubleBaseType;
   final BaseType numBaseType;
@@ skipping 395 matching lines @@
     final Map<Element, ConcreteType> result = new Map<Element, ConcreteType>();
     final FunctionSignature signature = function.computeSignature(compiler);
     // too many arguments
     if (argumentsTypes.length > signature.parameterCount) {
       return null;
     }
     // not enough arguments
     if (argumentsTypes.positional.length < signature.requiredParameterCount) {
       return null;
     }
-    final Iterator<ConcreteType> remainingPositionalArguments =
-        argumentsTypes.positional.iterator();
+    final HasNextIterator<ConcreteType> remainingPositionalArguments =
+        new HasNextIterator<ConcreteType>(argumentsTypes.positional.iterator);
     // we attach each positional parameter to its corresponding positional
     // argument
     for (Link<Element> requiredParameters = signature.requiredParameters;
          !requiredParameters.isEmpty;
          requiredParameters = requiredParameters.tail) {
       final Element requiredParameter = requiredParameters.head;
       // we know next() is defined because of the guard above
       result[requiredParameter] = remainingPositionalArguments.next();
     }
     // we attach the remaining positional arguments to their corresponding
@@ skipping 824 matching lines @@
   }
 
   void internalError(String reason, {Node node}) {
     inferrer.fail(node, reason);
   }
 
   ConcreteType visitTypeReferenceSend(Send) {
     return inferrer.singletonConcreteType(inferrer.baseTypes.typeBaseType);
   }
 }