fix #25486, promote from dynamic in strong mode

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 analyzer.test.generated.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 2258 matching lines @@
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     List<FunctionElement> functions = constructor.functions;
     expect(functions, isNotNull);
     expect(functions, hasLength(1));
     expect(functions[0].enclosingElement, constructor);
     assertErrors(source, [ParserErrorCode.GETTER_IN_FUNCTION]);
   }
 }
 
+/**
+ * Tests for generic method and function resolution that do not use strong mode.
+ */
+@reflectiveTest
+class GenericMethodResolverTest extends _StaticTypeAnalyzer2TestShared {
+  void setUp() {
+    super.setUp();
+    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
+    options.enableGenericMethods = true;
+    resetWithOptions(options);
+  }
+
+  void test_genericMethod_propagatedType_promotion() {
+    // Regression test for:
+    // https://github.com/dart-lang/sdk/issues/25340
+    //
+    // Note, after https://github.com/dart-lang/sdk/issues/25486 the original
+    // strong mode example won't work, as we now compute a static type and
+    // therefore discard the propagated type.
+    //
+    // So this test does not use strong mode.
+    _resolveTestUnit(r'''
+abstract class Iter {
+  List<S> map<S>(S f(x));
+}
+class C {}
+C toSpan(dynamic element) {
+  if (element is Iter) {
+    var y = element.map(toSpan);
+  }
+  return null;
+}''');
+    SimpleIdentifier y = _findIdentifier('y = ');
+    expect(y.staticType.toString(), 'dynamic');
+    expect(y.propagatedType.toString(), 'List<dynamic>');
+  }
+}
+
 @reflectiveTest
 class HintCodeTest extends ResolverTestCase {
   void fail_deadCode_statementAfterRehrow() {
     Source source = addSource(r'''
 f() {
   try {
     var one = 1;
   } catch (e) {
     rethrow;
     var two = 2;
@@ skipping 11300 matching lines @@
     expect(errors.map((e) => e.errorCode.name), [
       'STRONG_MODE_INVALID_METHOD_OVERRIDE',
       'INVALID_METHOD_OVERRIDE_TYPE_PARAMETERS'
     ]);
     verify([source]);
   }
 
   void test_genericMethod_propagatedType_promotion() {
     // Regression test for:
     // https://github.com/dart-lang/sdk/issues/25340
+
+    // Note, after https://github.com/dart-lang/sdk/issues/25486 the original
+    // example won't work, as we now compute a static type and therefore discard
+    // the propagated type. So a new test was created that doesn't run under
+    // strong mode.
     _resolveTestUnit(r'''
 abstract class Iter {
   List/*<S>*/ map/*<S>*/(/*=S*/ f(x));
 }
 class C {}
 C toSpan(dynamic element) {
   if (element is Iter) {
     var y = element.map(toSpan);
   }
   return null;
 }''');
     SimpleIdentifier y = _findIdentifier('y = ');
-    expect(y.staticType.toString(), 'dynamic');
-    expect(y.propagatedType.toString(), 'List<dynamic>');
+    expect(y.staticType.toString(), 'List<C>');
+    expect(y.propagatedType, isNull);
   }
 
   void test_genericMethod_tearoff() {
     _resolveTestUnit(r'''
 class C<E> {
   /*=T*/ f/*<T>*/(E e) => null;
   static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
   static final h = g;
 }
 
@@ skipping 3086 matching lines @@
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }