Test and fix resynthesized FunctionTypeImpl type args/params.

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 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/base.dart';
 import 'package:analyzer/src/summary/format.dart';
@@ skipping 331 matching lines @@
   }
 
   void compareTopLevelVariableElements(
       TopLevelVariableElementImpl resynthesized,
       TopLevelVariableElementImpl original,
       String desc) {
     comparePropertyInducingElements(resynthesized, original, desc);
     // TODO(paulberry): test evaluationResult
   }
 
-  void compareTypeImpls(TypeImpl resynthesized, TypeImpl original) {
-    expect(resynthesized.element.location, original.element.location);
-    expect(resynthesized.name, original.name);
+  void compareTypeImpls(
+      TypeImpl resynthesized, TypeImpl original, String desc) {
+    expect(resynthesized.element.location, original.element.location,
+        reason: desc);
+    expect(resynthesized.name, original.name, reason: desc);
   }
 
   void compareTypeParameterElements(TypeParameterElementImpl resynthesized,
       TypeParameterElementImpl original, String desc) {
     compareElements(resynthesized, original, desc);
     compareTypes(resynthesized.type, original.type, desc);
     compareTypes(resynthesized.bound, original.bound, '$desc bound');
   }
 
   void compareTypes(DartType resynthesized, DartType original, String desc) {
     if (original == null) {
       expect(resynthesized, isNull, reason: desc);
     } else if (resynthesized is InterfaceTypeImpl &&
         original is InterfaceTypeImpl) {
-      compareTypeImpls(resynthesized, original);
+      compareTypeImpls(resynthesized, original, desc);
       expect(resynthesized.typeArguments.length, original.typeArguments.length);
       for (int i = 0; i < resynthesized.typeArguments.length; i++) {
         compareTypes(resynthesized.typeArguments[i], original.typeArguments[i],
             '$desc type argument ${original.typeArguments[i].name}');
       }
     } else if (resynthesized is TypeParameterTypeImpl &&
         original is TypeParameterTypeImpl) {
-      compareTypeImpls(resynthesized, original);
+      compareTypeImpls(resynthesized, original, desc);
     } else if (resynthesized is DynamicTypeImpl &&
         original is DynamicTypeImpl) {
       expect(resynthesized, same(original));
     } else if (resynthesized is UndefinedTypeImpl &&
         original is UndefinedTypeImpl) {
       expect(resynthesized, same(original));
     } else if (resynthesized is FunctionTypeImpl &&
         original is FunctionTypeImpl) {
-      compareTypeImpls(resynthesized, original);
+      compareTypeImpls(resynthesized, original, desc);
       if (original.element.isSynthetic &&
           original.element is FunctionTypeAliasElementImpl &&
           resynthesized.element is FunctionTypeAliasElementImpl) {
         compareFunctionTypeAliasElements(
             resynthesized.element, original.element, desc);
       }
+      expect(resynthesized.typeArguments.length, original.typeArguments.length,
+          reason: desc);
       for (int i = 0; i < resynthesized.typeArguments.length; i++) {
         compareTypes(resynthesized.typeArguments[i], original.typeArguments[i],
             '$desc type argument ${original.typeArguments[i].name}');
       }
+      if (original.typeParameters == null) {
+        expect(resynthesized.typeParameters, isNull, reason: desc);
+      } else {
+        expect(resynthesized.typeParameters, isNotNull, reason: desc);
+        expect(
+            resynthesized.typeParameters.length, original.typeParameters.length,
+            reason: desc);
+        for (int i = 0; i < resynthesized.typeParameters.length; i++) {
+          compareTypeParameterElements(resynthesized.typeParameters[i],
+              original.typeParameters[i], '$desc type parameter $i');
+        }
+      }
+      expect(resynthesized.boundTypeParameters.length,
+          original.boundTypeParameters.length,
+          reason: desc);
+      for (int i = 0; i < resynthesized.boundTypeParameters.length; i++) {
+        compareTypeParameterElements(resynthesized.boundTypeParameters[i],
+            original.boundTypeParameters[i], '$desc bound type parameter $i');
+      }
     } else if (resynthesized is VoidTypeImpl && original is VoidTypeImpl) {
       expect(resynthesized, same(original));
     } else if (resynthesized.runtimeType != original.runtimeType) {
       fail(
           'Type mismatch: expected ${original.runtimeType}, got ${resynthesized.runtimeType}');
     } else {
       fail('Unimplemented comparison for ${original.runtimeType}');
     }
   }
 
@@ skipping 640 matching lines @@
   }
 
   test_variable_const() {
     checkLibrary('const int i = 0;');
   }
 
   test_variables() {
     checkLibrary('int i; int j;');
   }
 }