Roll Observatory deps (charted -> ^0.3.0)

packages/analyzer/lib/src/generated/static_type_analyzer.dart

 // Copyright (c) 2014, 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.
 
 library engine.resolver.static_type_analyzer;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/scanner.dart';
 
@@ skipping 1401 matching lines @@
     }
     if (body.isAsynchronous) {
       return _typeProvider.futureType
           .substitute4(<DartType>[flattenFutures(_typeProvider, type)]);
     } else {
       return type;
     }
   }
 
   // TODO(vsm): Use leafp's matchType here?
-  DartType _findIteratedType(InterfaceType type, DartType targetType) {
+  DartType _findIteratedType(DartType type, DartType targetType) {
     // Set by _find if match is found
     DartType result = null;
     // Elements we've already visited on a given inheritance path.
     HashSet<ClassElement> visitedClasses = null;
 
+    while (type is TypeParameterType) {
+      TypeParameterElement element = type.element;
+      type = element.bound;
+    }
+
     bool _find(InterfaceType type) {
       ClassElement element = type.element;
       if (type == _typeProvider.objectType || element == null) {
         return false;
       }
       if (element == targetType.element) {
         List<DartType> typeArguments = type.typeArguments;
         assert(typeArguments.length == 1);
         result = typeArguments[0];
         return true;
       }
       if (visitedClasses == null) {
         visitedClasses = new HashSet<ClassElement>();
       }
       // Already visited this class along this path
       if (!visitedClasses.add(element)) {
         return false;
       }
       try {
         return _find(type.superclass) ||
             type.interfaces.any(_find) ||
             type.mixins.any(_find);
       } finally {
         visitedClasses.remove(element);
       }
     }
-    _find(type);
+    if (type is InterfaceType) {
+      _find(type);
+    }
     return result;
   }
 
   /**
    * Return the best type of the given [expression].
    */
   DartType _getBestType(Expression expression) {
     return expression.bestType;
   }
 
@@ skipping 219 matching lines @@
    */
   void _inferForEachLoopVariableType(DeclaredIdentifier loopVariable) {
     if (loopVariable != null &&
         loopVariable.type == null &&
         loopVariable.parent is ForEachStatement) {
       ForEachStatement loop = loopVariable.parent;
       if (loop.iterable != null) {
         Expression expr = loop.iterable;
         LocalVariableElementImpl element = loopVariable.element;
         DartType exprType = expr.staticType;
-        if (exprType is InterfaceType) {
-          DartType targetType = (loop.awaitKeyword == null)
-              ? _typeProvider.iterableType
+        DartType targetType = (loop.awaitKeyword == null)
+          ? _typeProvider.iterableType
               : _typeProvider.streamType;
-          DartType iteratedType = _findIteratedType(exprType, targetType);
-          if (element != null && iteratedType != null) {
-            element.type = iteratedType;
-            loopVariable.identifier.staticType = iteratedType;
-          }
+        DartType iteratedType = _findIteratedType(exprType, targetType);
+        if (element != null && iteratedType != null) {
+          element.type = iteratedType;
+          loopVariable.identifier.staticType = iteratedType;
         }
       }
     }
   }
 
   /**
    * Given a method invocation [node], attempt to infer a better
    * type for the result.
    */
   bool _inferMethodInvocation(MethodInvocation node) {
@@ skipping 576 matching lines @@
     }
     // merge types
     if (result == null) {
       result = type;
     } else {
       result = _typeSystem.getLeastUpperBound(_typeProvider, result, type);
     }
     return null;
   }
 }