Don't set a propagate type if the variable has already the same static type.

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/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 6248 matching lines @@
     MemberMap map = new MemberMap();
     expect(map.size, 0);
     map.put(m1.name, m1);
     expect(map.size, 1);
     expect(map.get("m1"), m1);
   }
 }
 
 @reflectiveTest
 class NonHintCodeTest extends ResolverTestCase {
-  void fail_propagatedFieldType() {
-    // From dartbug.com/20019
-    Source source = addSource(r'''
-class A { }
-class X<T> {
-  final x = new List<T>();
-}
-class Z {
-  final X<A> y = new X<A>();
-  foo() {
-    y.x.add(new A());
-  }
-}''');
-    resolve(source);
-    assertNoErrors(source);
-    verify([source]);
-  }
-
   void test_deadCode_deadBlock_conditionalElse_debugConst() {
     Source source = addSource(r'''
 const bool DEBUG = true;
 f() {
   DEBUG ? 1 : 2;
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
@@ skipping 408 matching lines @@
 }
 class B extends A {
   @override
   set m(int x) {}
 }''');
     resolve(source);
     assertNoErrors(source);
     verify([source]);
   }
 
+  void test_propagatedFieldType() {
+    Source source = addSource(r'''
+class A { }
+class X<T> {
+  final x = new List<T>();
+}
+class Z {
+  final X<A> y = new X<A>();
+  foo() {
+    y.x.add(new A());
+  }
+}''');
+    resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+  }
+
   void test_proxy_annotation_prefixed() {
     Source source = addSource(r'''
 library L;
 @proxy
 class A {}
 f(var a) {
   a = new A();
   a.m();
   var x = a.g;
   a.s = 1;
@@ skipping 5261 matching lines @@
     FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ExpressionStatement statement =
         body.block.statements[1] as ExpressionStatement;
     PrefixedIdentifier invocation = statement.expression as PrefixedIdentifier;
     SimpleIdentifier variableName = invocation.prefix;
     expect(variableName.propagatedType, same(typeProvider.stringType));
   }
 
+  void test_initializer_hasStaticType() {
+    Source source = addSource(r'''
+f() {
+  int v = 0;
+  return v;
+}''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
+    BlockFunctionBody body =
+        function.functionExpression.body as BlockFunctionBody;
+    NodeList<Statement> statements = body.block.statements;
+    // Type of 'v' in declaration.
+    {
+      VariableDeclarationStatement statement =
+          statements[0] as VariableDeclarationStatement;
+      SimpleIdentifier variableName = statement.variables.variables[0].name;
+      expect(variableName.staticType, same(typeProvider.intType));
+      expect(variableName.propagatedType, isNull);
+    }
+    // Type of 'v' in reference.
+    {
+      ReturnStatement statement = statements[1] as ReturnStatement;
+      SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
+      expect(variableName.staticType, same(typeProvider.intType));
+      expect(variableName.propagatedType, isNull);
+    }
+  }
+
+  void test_initializer_hasStaticType_parameterized() {
+    Source source = addSource(r'''
+f() {
+  List<int> v = <int>[];
+  return v;
+}''');
+    LibraryElement library = resolve(source);
+    assertNoErrors(source);
+    verify([source]);
+    CompilationUnit unit = resolveCompilationUnit(source, library);
+    FunctionDeclaration function = unit.declarations[0] as FunctionDeclaration;
+    BlockFunctionBody body =
+        function.functionExpression.body as BlockFunctionBody;
+    NodeList<Statement> statements = body.block.statements;
+    // Type of 'v' in declaration.
+    {
+      VariableDeclarationStatement statement =
+          statements[0] as VariableDeclarationStatement;
+      SimpleIdentifier variableName = statement.variables.variables[0].name;
+      expect(variableName.staticType, isNotNull);
+      expect(variableName.propagatedType, isNull);
+    }
+    // Type of 'v' in reference.
+    {
+      ReturnStatement statement = statements[1] as ReturnStatement;
+      SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
+      expect(variableName.staticType, isNotNull);
+      expect(variableName.propagatedType, isNull);
+    }
+  }
+
   void test_initializer_null() {
     String code = r'''
 main() {
   int v = null;
   return v; // marker
 }''';
     CompilationUnit unit;
     {
       Source source = addSource(code);
       LibraryElement library = resolve(source);
@@ skipping 1394 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;
   }
 }