Fix summarizing of types with unused 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 1058 matching lines @@
         expect(resynthesized.element, new isInstanceOf<FunctionElement>());
         expect(resynthesized.element.enclosingElement, isNull, reason: desc);
         compareFunctionElements(
             resynthesized.element, original.element, '$desc element',
             shallow: true);
         expect(resynthesized.element.type, same(resynthesized));
       }
       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 (resynthesized.typeArguments[i].isDynamic &&
+            original.typeArguments[i] is TypeParameterType) {
+          // It's ok for type arguments to get converted to `dynamic` if they
+          // are not used.
+          expect(
+              isTypeParameterUsed(
+                  original.typeArguments[i], original.element.type),
+              isFalse);
+        } else {
+          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],
@@ skipping 147 matching lines @@
       return getActualElement(actualElement, desc);
     } else if (element is Member) {
       return getActualElement(element.baseElement, desc);
     } else {
       fail('Unexpected type for resynthesized ($desc):'
           ' ${element.runtimeType}');
       return null;
     }
   }
 
+  /**
+   * Determine if [type] makes use of the given [typeParameter].
+   */
+  bool isTypeParameterUsed(TypeParameterType typeParameter, DartType type) {
+    if (type is FunctionType) {
+      return isTypeParameterUsed(typeParameter, type.returnType) ||
+          type.parameters.any((ParameterElement e) =>
+              isTypeParameterUsed(typeParameter, e.type));
+    } else if (type is InterfaceType) {
+      return type.typeArguments
+          .any((DartType t) => isTypeParameterUsed(typeParameter, t));
+    } else if (type is TypeParameterType) {
+      return type == typeParameter;
+    } else {
+      expect(type.isDynamic || type.isVoid, isTrue);
+      return false;
+    }
+  }
+
   @override
   void setUp() {
     super.setUp();
     prepareAnalysisContext(createOptions());
   }
 
   test_class_abstract() {
     checkLibrary('abstract class C {}');
   }
 
@@ skipping 2823 matching lines @@
   }
 
   test_typedef_type_parameters_f_bound_simple() {
     checkLibrary('typedef U F<T extends U, U>(T t);');
   }
 
   test_typedefs() {
     checkLibrary('f() {} g() {}');
   }
 
+  test_unused_type_parameter() {
+    checkLibrary('''
+class C<T> {
+  void f() {}
+}
+C<int> c;
+var v = c.f;
+''');
+  }
+
   test_variable_const() {
     checkLibrary('const int i = 0;');
   }
 
   test_variable_documented() {
     checkLibrary('''
 // Extra comment so doc comment offset != 0
 /**
  * Docs
  */
@@ skipping 127 matching lines @@
       fail('Unexpectedly tried to get unlinked summary for $uri');
     }
     return serializedUnit;
   }
 
   @override
   bool hasLibrarySummary(String uri) {
     return true;
   }
 }