Fix for resynthesizing default values referencing type parameters.

pkg/analyzer/test/src/summary/resynthesize_test.dart

 // Copyright (c) 2015, 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 test.src.serialization.elements_test;
 
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/constant/value.dart';
@@ skipping 497 matching lines @@
         // to check that their constructor initializers match, because that
         // could lead to infinite regress.
         compareElements(
             rConstructor.staticElement, oConstructor.staticElement, desc);
         TypeName oType = oConstructor.type;
         TypeName rType = rConstructor.type;
         expect(oType, isNotNull, reason: desc);
         expect(rType, isNotNull, reason: desc);
         compareConstAsts(rType.name, oType.name, desc);
         compareConstAsts(rConstructor.name, oConstructor.name, desc);
-        compareConstAstLists(rType.typeArguments?.arguments,
-            oType.typeArguments?.arguments, desc);
+        // In strong mode type inference is performed, so that
+        // `C<int> v = new C();` is serialized as `C<int> v = new C<int>();`.
+        // So, if there are not type arguments originally, not need to check.
+        if (oType.typeArguments?.arguments?.isNotEmpty ?? false) {
+          compareConstAstLists(rType.typeArguments?.arguments,
+              oType.typeArguments?.arguments, desc);
+        }
         compareConstAstLists(
             r.argumentList.arguments, o.argumentList.arguments, desc);
       } else if (o is AnnotationImpl && r is AnnotationImpl) {
         expect(o.atSign.lexeme, r.atSign.lexeme, reason: desc);
         Identifier rName = r.name;
         Identifier oName = o.name;
         if (oName is PrefixedIdentifier && o.constructorName != null) {
           // E.g. `@prefix.cls.ctor`.  This gets resynthesized as `@cls.ctor`,
           // with `cls.ctor` represented as a PrefixedIdentifier.
           expect(rName, new isInstanceOf<PrefixedIdentifier>(), reason: desc);
@@ skipping 1990 matching lines @@
 
   test_constExpr_pushReference_staticMethod_simpleIdentifier() {
     checkLibrary('''
 class C {
   static const a = m;
   static m() {}
 }
 ''');
   }
 
+  test_constructor_default_refers_to_generic_class() {
+    checkLibrary('''
+class B<T> {
+  const B();
+}
+class C<T> {
+  const C([B<T> b = const B()]);
+}
+''');
+  }
+
+  test_constructor_default_refers_to_generic_class2() {
+    checkLibrary('''
+abstract class A<T> {}
+class B<T> implements A<T> {
+  const B();
+}
+class C<T> implements A<Iterable<T>> {
+  const C([A<T> a = const B()]);
+}
+''');
+  }
+
   test_constructor_documented() {
     checkLibrary('''
 class C {
   /**
    * Docs
    */
   C();
 }''');
   }
 
@@ skipping 1988 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }