Fix ast-based serialization of out-of-scope type parameters.

pkg/analyzer/test/src/summary/summary_common.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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 7531 matching lines @@
 
   test_import_uri() {
     String uriString = '"dart:async"';
     String libraryText = 'import $uriString; Future x;';
     serializeLibraryText(libraryText);
     // Second import is the implicit import of dart:core
     expect(unlinkedUnits[0].imports, hasLength(2));
     expect(unlinkedUnits[0].imports[0].uri, 'dart:async');
   }
 
+  test_inferred_function_type_parameter_type_with_unrelated_type_param() {
+    if (!strongMode || skipFullyLinkedData) {
+      return;
+    }
+    // The type that is inferred for C.f's parameter g is "() -> void".
+    // Since the associated element for that function type is B.f's parameter g,
+    // and B has a type parameter, the inferred type will record a type
+    // parameter.  However, since that type parameter is irrelevant, the summary
+    // should encode it as `dynamic`.
+    UnlinkedClass c = serializeClassText('''
+abstract class B<T> {
+  void f(void g());
+}
+class C<T> extends B<T> {
+  void f(g) {}
+}
+''');
+    expect(c.executables, hasLength(1));
+    UnlinkedExecutable f = c.executables[0];
+    expect(f.parameters, hasLength(1));
+    UnlinkedParam g = f.parameters[0];
+    expect(g.name, 'g');
+    EntityRef typeRef = getTypeRefForSlot(g.inferredTypeSlot);
+    checkLinkedTypeRef(typeRef, null, null, 'f',
+        expectedKind: ReferenceKind.method, allowTypeArguments: true);
+    expect(typeRef.typeArguments, hasLength(1));
+    checkLinkedTypeRef(typeRef.typeArguments[0], null, null, 'dynamic');
+  }
+
   test_inferred_type_keeps_leading_dynamic() {
     if (!strongMode || skipFullyLinkedData) {
       return;
     }
     UnlinkedClass cls =
         serializeClassText('class C { final x = <dynamic, int>{}; }');
     EntityRef type = getTypeRefForSlot(cls.fields[0].inferredTypeSlot);
     // Check that x has inferred type `Map<dynamic, int>`.
     checkLinkedTypeRef(type, 'dart:core', 'dart:core', 'Map',
         allowTypeArguments: true, numTypeParameters: 2);
@@ skipping 2269 matching lines @@
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
 }