Fix some corner cases of resynthesizing generic function types.

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/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/base.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/resynthesize.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart';
 import 'package:unittest/unittest.dart';
 
 import '../../generated/resolver_test.dart';
 import '../../reflective_tests.dart';
 
@@ skipping 372 matching lines @@
       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, desc);
+      expect(resynthesized.isInstantiated, original.isInstantiated,
+          reason: 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],
@@ skipping 389 matching lines @@
   }
 
   test_function_return_type_implicit() {
     checkLibrary('f() => null;');
   }
 
   test_function_return_type_void() {
     checkLibrary('void f() {}');
   }
 
+  test_function_type_parameter() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    checkLibrary('T f<T, U>(U u) => null;');
+  }
+
+  test_function_type_parameter_with_function_typed_parameter() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    checkLibrary('void f<T, U>(T x(U u)) {}');
+  }
+
   test_functions() {
     checkLibrary('f() {} g() {}');
   }
 
   test_getter_external() {
     checkLibrary('external int get x;');
   }
 
   test_getters() {
     checkLibrary('int get x => null; get y => null;');
@@ skipping 42 matching lines @@
   }
 
   test_method_parameter_return_type() {
     checkLibrary('class C { f(int g()) {} }');
   }
 
   test_method_parameter_return_type_void() {
     checkLibrary('class C { f(void g()) {} }');
   }
 
+  test_method_type_parameter() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    checkLibrary('class C { T f<T, U>(U u) => null; }');
+  }
+
+  test_method_type_parameter_in_generic_class() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
+  }
+
+  test_method_type_parameter_with_function_typed_parameter() {
+    resetWithOptions(new AnalysisOptionsImpl()..enableGenericMethods = true);
+    checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
+  }
+
   test_operator() {
     checkLibrary('class C { C operator+(C other) => null; }');
   }
 
   test_operator_equal() {
     checkLibrary('class C { bool operator==(C other) => false; }');
   }
 
   test_operator_external() {
     checkLibrary('class C { external C operator+(C other); }');
@@ skipping 228 matching lines @@
   }
 
   test_variable_implicit_type() {
     checkLibrary('var x;');
   }
 
   test_variables() {
     checkLibrary('int i; int j;');
   }
 }