Strong mode foreach inference. Infer the type of declared identifiers

pkg/analyzer/lib/src/generated/resolver.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;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'constant.dart';
@@ skipping 10833 matching lines @@
           LocalVariableElement loopElement = loopVariable.element;
           if (loopElement != null) {
             DartType propagatedType = null;
             if (node.awaitKeyword == null) {
               propagatedType = _getIteratorElementType(iterable);
             } else {
               propagatedType = _getStreamElementType(iterable);
             }
             if (propagatedType != null) {
               overrideVariable(loopElement, propagatedType, true);
-              _recordPropagatedType(loopVariable.identifier, propagatedType);
+              recordPropagatedTypeIfBetter(
+                  loopVariable.identifier, propagatedType);
             }
           }
         } else if (identifier != null && iterable != null) {
           Element identifierElement = identifier.staticElement;
           if (identifierElement is VariableElement) {
             DartType iteratorElementType = _getIteratorElementType(iterable);
             overrideVariable(identifierElement, iteratorElementType, true);
-            _recordPropagatedType(identifier, iteratorElementType);
+            recordPropagatedTypeIfBetter(identifier, iteratorElementType);
           }
         }
         visitStatementInScope(body);
       } finally {
         _overrideManager.exitScope();
       }
     }
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
   }
@@ skipping 719 matching lines @@
       }
     } else if (condition is PrefixExpression) {
       PrefixExpression prefix = condition;
       if (prefix.operator.type == sc.TokenType.BANG) {
         _propagateFalseState(prefix.operand);
       }
     } else if (condition is ParenthesizedExpression) {
       _propagateTrueState(condition.expression);
     }
   }
-
-  /**
-   * Record that the propagated type of the given node is the given type.
-   *
-   * @param expression the node whose type is to be recorded
-   * @param type the propagated type of the node
-   */
-  void _recordPropagatedType(Expression expression, DartType type) {
-    if (type != null && !type.isDynamic) {
-      expression.propagatedType = type;
-    }
-  }
 }
 
 /**
  * The abstract class `Scope` defines the behavior common to name scopes used by the resolver
  * to determine which names are visible at any given point in the code.
  */
 abstract class Scope {
   /**
    * The prefix used to mark an identifier as being private to its library.
    */
@@ skipping 3776 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }