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

pkg/analyzer/lib/src/summary/link.dart

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 162 matching lines @@
     result.reference = compilationUnit.addRawReference('dynamic');
     return result;
   } else if (type is VoidTypeImpl) {
     result.reference = compilationUnit.addRawReference('void');
     return result;
   } else if (type is BottomTypeImpl) {
     result.reference = compilationUnit.addRawReference('*bottom*');
     return result;
   } else if (type is TypeParameterType) {
     TypeParameterElementForLink element = type.element;
-    result.paramReference =
-        typeParameterContext.typeParameterNestingLevel - element.nestingLevel;
+    if (typeParameterContext.isTypeParameterInScope(element)) {
+      result.paramReference =
+          typeParameterContext.typeParameterNestingLevel - element.nestingLevel;
+    } else {
+      // Out-of-scope type parameters only occur in circumstances where they
+      // are irrelevant (i.e. when a type parameter is unused).  So we can
+      // safely convert them to `dynamic`.
+      result.reference = compilationUnit.addRawReference('dynamic');
+    }
     return result;
   } else if (type is FunctionType) {
     Element element = type.element;
     if (element is FunctionElementForLink_FunctionTypedParam) {
       result.reference =
           compilationUnit.addReference(element.typeParameterContext);
       result.implicitFunctionTypeIndices = element.implicitFunctionTypeIndices;
       _storeTypeArguments(
           type.typeArguments, result, compilationUnit, typeParameterContext);
       return result;
@@ skipping 3995 matching lines @@
       return types[types.length - index];
     } else if (enclosingTypeParameterContext != null) {
       return enclosingTypeParameterContext
           .getTypeParameterType(index - types.length);
     } else {
       // If we get here, it means that a summary contained a type parameter index
       // that was out of range.
       throw new RangeError('Invalid type parameter index');
     }
   }
+
+  /**
+   * Find out if the given [typeParameter] is in scope in this context.
+   */
+  bool isTypeParameterInScope(TypeParameterElementForLink typeParameter) {
+    if (typeParameter.enclosingElement == this) {
+      return true;
+    } else if (enclosingTypeParameterContext != null) {
+      return enclosingTypeParameterContext
+          .isTypeParameterInScope(typeParameter);
+    } else {
+      return false;
+    }
+  }
 }
 
 class TypeProviderForLink implements TypeProvider {
   final Linker _linker;
 
   InterfaceType _boolType;
   InterfaceType _deprecatedType;
   InterfaceType _doubleType;
   InterfaceType _functionType;
   InterfaceType _futureDynamicType;
@@ skipping 311 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementForLink get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }