Refactor the logic for inferring for-each loop variable types.

Currently we only use this logic when the for-each loop declares its
own loop variable, and that loop variable doesn't have an explicit
type.  However, for NNBD, we'll need to use the same logic for when
the for-each loop doesn't declare its own loop variable, so that flow
analysis can see whether the implicit assignment to the loop variable
should un-do type promotions or not.  Since flow analysis integrates
via the ResolverVisitor, we need the inferred type to be accessible to
the ResolverVisitor.  So we create a new method
`StaticTypeAnalyzer.computeForEachElementType` to compute the type,
and call it from `ResolverVisitor`.

Change-Id: I544d72371a6c710297e467b9b37bd909490a7336
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/122880
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/analyzer/lib/src/generated/resolver.dart

@@ -3513,6 +3513,15 @@ class ResolverVisitor extends ScopedVisitor {
       //
       iterable?.accept(this);
       loopVariable?.accept(this);
+      var elementType = typeAnalyzer.computeForEachElementType(
+          iterable, node.awaitKeyword != null);
+      if (loopVariable != null &&
+          elementType != null &&
+          loopVariable.type == null) {
+        var loopVariableElement =
+            loopVariable.declaredElement as LocalVariableElementImpl;
+        loopVariableElement.type = elementType;
+      }
       _flowAnalysis?.flow?.forEach_bodyBegin(
           node,
           identifierElement is VariableElement
@@ -3592,6 +3601,15 @@ class ResolverVisitor extends ScopedVisitor {
       //
       iterable?.accept(this);
       loopVariable?.accept(this);
+      var elementType = typeAnalyzer.computeForEachElementType(
+          iterable, node.awaitKeyword != null);
+      if (loopVariable != null &&
+          elementType != null &&
+          loopVariable.type == null) {
+        var loopVariableElement =
+            loopVariable.declaredElement as LocalVariableElementImpl;
+        loopVariableElement.type = elementType;
+      }
 
       _flowAnalysis?.flow?.forEach_bodyBegin(
           node,

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

@@ -132,6 +132,31 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
    */
   bool get _nonNullableEnabled => _featureSet.isEnabled(Feature.non_nullable);
 
+  /**
+   * Given an iterable expression from a foreach loop, attempt to infer
+   * a type for the elements being iterated over.  Inference is based
+   * on the type of the iterator or stream over which the foreach loop
+   * is defined.
+   */
+  DartType computeForEachElementType(Expression iterable, bool isAsync) {
+    DartType iterableType = iterable.staticType;
+    if (iterableType == null) return null;
+    iterableType = iterableType.resolveToBound(_typeProvider.objectType);
+
+    ClassElement iteratedElement =
+        isAsync ? _typeProvider.streamElement : _typeProvider.iterableElement;
+
+    InterfaceType iteratedType = iterableType is InterfaceTypeImpl
+        ? iterableType.asInstanceOf(iteratedElement)
+        : null;
+
+    if (iteratedType != null) {
+      return iteratedType.typeArguments.single;
+    } else {
+      return null;
+    }
+  }
+
   /**
    * Given a constructor name [node] and a type [type], record an inferred type
    * for the constructor if in strong mode. This is used to fill in any
@@ -545,12 +570,6 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     _analyzeLeastUpperBound(node, node.thenExpression, node.elseExpression);
   }
 
-  @override
-  void visitDeclaredIdentifier(DeclaredIdentifier node) {
-    super.visitDeclaredIdentifier(node);
-    _inferForEachLoopVariableType(node);
-  }
-
   /**
    * The Dart Language Specification, 12.3: <blockquote>The static type of a literal double is
    * double.</blockquote>
@@ -1640,52 +1659,6 @@ class StaticTypeAnalyzer extends SimpleAstVisitor<void> {
     }
   }
 
-  /**
-   * Given a declared identifier from a foreach loop, attempt to infer
-   * a type for it if one is not already present.  Inference is based
-   * on the type of the iterator or stream over which the foreach loop
-   * is defined.
-   */
-  void _inferForEachLoopVariableType(DeclaredIdentifier loopVariable) {
-    if (loopVariable != null && loopVariable.type == null) {
-      AstNode parent = loopVariable.parent;
-      Token awaitKeyword;
-      Expression iterable;
-      if (parent is ForEachPartsWithDeclaration) {
-        AstNode parentParent = parent.parent;
-        if (parentParent is ForStatementImpl) {
-          awaitKeyword = parentParent.awaitKeyword;
-        } else if (parentParent is ForElement) {
-          awaitKeyword = parentParent.awaitKeyword;
-        } else {
-          return;
-        }
-        iterable = parent.iterable;
-      } else {
-        return;
-      }
-      if (iterable != null) {
-        LocalVariableElementImpl element = loopVariable.declaredElement;
-
-        DartType iterableType = iterable.staticType;
-        iterableType = iterableType.resolveToBound(_typeProvider.objectType);
-
-        ClassElement iteratedElement = (awaitKeyword == null)
-            ? _typeProvider.iterableElement
-            : _typeProvider.streamElement;
-
-        InterfaceType iteratedType = iterableType is InterfaceTypeImpl
-            ? iterableType.asInstanceOf(iteratedElement)
-            : null;
-
-        if (element != null && iteratedType != null) {
-          DartType elementType = iteratedType.typeArguments.single;
-          element.type = elementType;
-        }
-      }
-    }
-  }
-
   /**
    * Given a possibly generic invocation like `o.m(args)` or `(f)(args)` try to
    * infer the instantiated generic function type.