Strong mode foreach inference. Infer the type of declared identifiers

pkg/analyzer/test/generated/resolver_test.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_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/context/context.dart' as newContext;
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 8036 matching lines @@
             return variable;
           }
         }
       }
     }
     return null;
     // Not found
   }
 
   /**
+   * @param code the code that iterates using variable "v". We check that
+   *          "v" has expected static and propagated type.
+   */
+  void _assertPropagatedIterationType(String code, DartType expectedStaticType,
+      DartType expectedPropagatedType) {
+    SimpleIdentifier identifier = _findMarkedIdentifier(code, "v in ");
+    expect(identifier.staticType, same(expectedStaticType));
+    expect(identifier.propagatedType, same(expectedPropagatedType));
+  }
+
+  /**
    * @param code the code that assigns the value to the variable "v", no matter how. We check that
    *          "v" has expected static and propagated type.
    */
   void _assertPropagatedAssignedType(String code, DartType expectedStaticType,
       DartType expectedPropagatedType) {
     SimpleIdentifier identifier = _findMarkedIdentifier(code, "v = ");
     expect(identifier.staticType, same(expectedStaticType));
     expect(identifier.propagatedType, same(expectedPropagatedType));
   }
 
@@ skipping 5664 matching lines @@
 main() {
   var v;
   v = 3;
   return v; // marker
 }''';
     _assertPropagatedAssignedType(
         code, typeProvider.dynamicType, typeProvider.intType);
     _assertTypeOfMarkedExpression(
         code, typeProvider.dynamicType, typeProvider.intType);
   }
+
+  void test_foreachInference_var() {
+    String code = r'''
+main() {
+  var list = <int>[];
+  for (var v in list) {
+    v; // marker
+  }
+}''';
+    _assertPropagatedIterationType(
+        code, typeProvider.intType, typeProvider.intType);

[Brian Wilkerson, 2015/08/28 20:59:33]

I might be misreading the test, but it looks like we're expecting 'v' to have a
propagated type that is equal to the static type. I don't know that it matters
in practice, but we generally only keep a propagated type if it's more specific
than the static type. I'd like to understand why the propagated type isn't null
here.

The propagated type is computed in ResolverVisitor.visitForEachStatementInScope.
I'm guessing that we just need to disable that code when strong mode is enabled.

[Leaf, 2015/09/01 21:21:02]

I changed visitForEachStatementInScope as discussed to only record the
propagated type if it is better.

+    _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+  }
+
+  void test_foreachInference_dynamic_disabled() {
+    String code = r'''
+main() {
+  var list = <int>[];
+  for (dynamic v in list) {
+    v; // marker
+  }
+}''';
+    _assertPropagatedIterationType(
+        code, typeProvider.dynamicType, typeProvider.intType);
+    _assertTypeOfMarkedExpression(
+        code, typeProvider.dynamicType, typeProvider.intType);
+  }
+
+  void test_foreachInference_reusedVar_disabled() {
+    String code = r'''
+main() {
+  var list = <int>[];
+  var v;
+  for (v in list) {
+    v; // marker
+  }
+}''';
+    _assertPropagatedIterationType(
+        code, typeProvider.dynamicType, typeProvider.intType);
+    _assertTypeOfMarkedExpression(
+        code, typeProvider.dynamicType, typeProvider.intType);
+  }
+
+  void fail_foreachInference_var_map() {
+    String code = r'''
+main() {
+  Map<int, String> map = <int, String>{};
+  for (var v in map) {
+    v; // marker
+  }
+}''';
+    _assertPropagatedIterationType(code, typeProvider.intType, null);
+    _assertTypeOfMarkedExpression(code, typeProvider.intType, null);
+  }
 }
 
 @reflectiveTest
 class TypeProviderImplTest extends EngineTestCase {
   void test_creation() {
     //
     // Create a mock library element with the types expected to be in dart:core.
     // We cannot use either ElementFactory or TestTypeProvider (which uses
     // ElementFactory) because we side-effect the elements in ways that would
     // break other tests.
@@ skipping 766 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }