[nnbd_migration] Handle downcasting type arguments.

There are no examples of a downcast involving a nullable type in the
current set of working packages. This tells me that it's rare, and that
this behavior should be good enough.

If we're wrong, this unblocks packages and we can revisit this decision
later.

Change-Id: Ic4e23cc6a848b83b2d1fb6c97ff513c3cc9fdb2e
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/128778
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Mike Fairhurst <mfairhurst@google.com>

Author: MichaelRFairhurst

pkg/nnbd_migration/lib/src/edge_builder.dart

@@ -2528,11 +2528,18 @@ mixin _AssignmentChecker {
           destination: _getTypeParameterTypeBound(destination),
           hard: false);
     } else if (destinationType is InterfaceType) {
-      assert(source.typeArguments.isEmpty,
-          'downcast from interface type with type args not supported.');
-      for (final param in destinationType.element.typeParameters) {
-        assert(param.bound == null,
-            'downcast to type parameters with bounds not supported');
+      if (source.type is InterfaceType) {
+        final target = _decoratedClassHierarchy.asInstanceOf(
+            destination, source.type.element as ClassElement);
+        for (var i = 0; i < source.typeArguments.length; ++i) {
+          _checkDowncast(origin,
+              source: source.typeArguments[i],
+              destination: target.typeArguments[i],
+              hard: false);
+        }
+      } else {
+        assert(false,
+            'downcasting from ${source.type.runtimeType} to interface type');
       }
     } else if (destinationType is FunctionType) {
       if (source.type.isDartCoreFunction) {

pkg/nnbd_migration/test/api_test.dart

@@ -1018,6 +1018,26 @@ void f(dynamic a) {
     await _checkSingleFileChanges(content, expected);
   }
 
+  test_downcast_dynamic_type_argument() async {
+    // This pattern is common and seems to have this as a best migration. It is
+    // less clear, but plausible, that this holds for other types of type
+    // parameter downcasts.
+    var content = '''
+List<int> f(List a) => a;
+void main() {
+  f(<int>[null]);
+}
+''';
+
+    var expected = '''
+List<int?> f(List a) => a;
+void main() {
+  f(<int?>[null]);
+}
+''';
+    await _checkSingleFileChanges(content, expected);
+  }
+
   @failingTest
   test_downcast_not_widest_type_type_parameters() async {
     // Fails because a hard assignment from List<int/*1*/> to List<int/*2*/>
@@ -1054,6 +1074,26 @@ void f(dynamic a) {
     await _checkSingleFileChanges(content, expected);
   }
 
+  test_downcast_type_argument_preserve_nullability() async {
+    // There are no examples in front of us yet where anyone downcasts a type
+    // with a nullable type parameter. This is maybe correct, maybe not, and it
+    // unblocks us to find out which at a later point in time.
+    var content = '''
+List<int> f(Iterable<num> a) => a;
+void main() {
+  f(<num>[null]);
+}
+''';
+
+    var expected = '''
+List<int?> f(Iterable<num?> a) => a;
+void main() {
+  f(<num?>[null]);
+}
+''';
+    await _checkSingleFileChanges(content, expected);
+  }
+
   @failingTest
   test_downcast_widest_type_from_related_type_parameters() async {
     var content = '''

pkg/nnbd_migration/test/edge_builder_test.dart

@@ -195,7 +195,6 @@ class AssignmentCheckerTest extends Object
     assertNoEdge(t.typeArguments[0].node, anyNode);
   }
 
-  @failingTest
   test_generic_to_generic_downcast() {
     var t1 = list(list(object()));
     var t2 = myListOfList(object());
@@ -212,6 +211,14 @@ class AssignmentCheckerTest extends Object
     assertEdge(b, substitutionNode(a, c), hard: false);
   }
 
+  test_generic_to_generic_downcast_same_element() {
+    var t1 = list(object());
+    var t2 = list(int_());
+    assign(t1, t2, hard: true);
+    assertEdge(t1.node, t2.node, hard: true);
+    assertEdge(t1.typeArguments[0].node, t2.typeArguments[0].node, hard: false);
+  }
+
   test_generic_to_generic_same_element() {
     var t1 = list(object());
     var t2 = list(object());