Fix a corner case of building summaries from ASTs.

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 170 matching lines @@
   void link(LinkedUnitBuilder linkedUnit);
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * Element representing a class resynthesized from a summary during
  * linking.
  */
-class ClassElementForLink_Class extends ClassElementForLink {
+class ClassElementForLink_Class extends ClassElementForLink
+    implements TypeParameterContext {
   /**
    * The unlinked representation of the class in the summary.
    */
   final UnlinkedClass _unlinkedClass;
 
   @override
   final CompilationUnitElementForLink enclosingElement;
 
   List<ConstructorElementForLink> _constructors;
   ConstructorElementForLink _unnamedConstructor;
   bool _unnamedConstructorComputed = false;
   List<FieldElementForLink_ClassField> _fields;
   InterfaceTypeForLink _supertype;
   InterfaceTypeForLink _type;
+  List<TypeParameterTypeForLink> _typeParameterTypes;
 
   ClassElementForLink_Class(this.enclosingElement, this._unlinkedClass);
 
   @override
   List<ConstructorElementForLink> get constructors {
     if (_constructors == null) {
       _constructors = <ConstructorElementForLink>[];
       for (UnlinkedExecutable unlinkedExecutable
           in _unlinkedClass.executables) {
         if (unlinkedExecutable.kind == UnlinkedExecutableKind.constructor) {
@@ skipping 20 matching lines @@
   bool get isObject => _unlinkedClass.hasNoSupertype;
 
   @override
   String get name => _unlinkedClass.name;
 
   @override
   InterfaceTypeForLink get supertype {
     if (isObject) {
       return null;
     }
-    return _supertype ??= _unlinkedClass.supertype == null
-        ? enclosingElement.enclosingElement._linker.objectType
-        : enclosingElement._resolveTypeRef(_unlinkedClass.supertype);
+    return _supertype ??= _computeSupertype();
+  }
+
+  /**
+   * Get a list of [TypeParameterTypeForLink] objects corresponding to the
+   * class's type parameters.
+   */
+  List<TypeParameterTypeForLink> get typeParameterTypes {
+    if (_typeParameterTypes == null) {
+      _typeParameterTypes = _unlinkedClass.typeParameters
+          .map((UnlinkedTypeParam _) => new TypeParameterTypeForLink())
+          .toList();
+    }
+    return _typeParameterTypes;
   }
 
   @override
   ConstructorElementForLink get unnamedConstructor {
     if (!_unnamedConstructorComputed) {
       for (ConstructorElementForLink constructor in constructors) {
         if (constructor.name.isEmpty) {
           _unnamedConstructor = constructor;
           break;
         }
       }
       _unnamedConstructorComputed = true;
     }
     return _unnamedConstructor;
   }
 
   @override
   DartTypeForLink buildType(DartTypeForLink getTypeArgument(int i),
       List<int> implicitFunctionTypeIndices) {
     if (_unlinkedClass.typeParameters.length != 0) {
       return new InterfaceTypeForLink(this);
     } else {
       return _type ??= new InterfaceTypeForLink(this);
     }
   }
 
   @override
+  TypeParameterTypeForLink getTypeParameterType(int index) {
+    List<TypeParameterTypeForLink> types = typeParameterTypes;
+    return types[types.length - index];
+  }
+
+  @override
   void link(LinkedUnitBuilder linkedUnit) {
     for (ConstructorElementForLink constructorElement in constructors) {
       constructorElement.link(linkedUnit);
     }
   }
+
+  InterfaceTypeForLink _computeSupertype() {
+    if (_unlinkedClass.supertype != null) {
+      DartTypeForLink supertype =
+          enclosingElement._resolveTypeRef(_unlinkedClass.supertype, this);
+      if (supertype is InterfaceTypeForLink) {
+        return supertype;
+      }
+      // In the event that the supertype isn't an interface type (which may
+      // happen in the event of erroneous code) just fall through and pretend
+      // the supertype is `Object`.
+    }
+    return enclosingElement.enclosingElement._linker.objectType;
+  }
 }
 
 /**
  * Element representing an enum resynthesized from a summary during
  * linking.
  */
 class ClassElementForLink_Enum extends ClassElementForLink {
   /**
    * The unlinked representation of the enum in the summary.
    */
@@ skipping 168 matching lines @@
     return _references[index];
   }
 
   /**
    * Resolve an [EntityRef] into a type.  If the reference is
    * unresolved, return [DynamicTypeImpl.instance].
    *
    * TODO(paulberry): or should we have a class representing an
    * unresolved type, for consistency with the full element model?
    */
-  DartTypeForLink _resolveTypeRef(EntityRef type, {bool defaultVoid: false}) {
+  DartTypeForLink _resolveTypeRef(
+      EntityRef type, TypeParameterContext typeParameterContext,
+      {bool defaultVoid: false}) {
     if (type == null) {
       if (defaultVoid) {
         return VoidTypeForLink.instance;
       } else {
         return DynamicTypeForLink.instance;
       }
     }
     if (type.paramReference != 0) {
-      // TODO(paulberry): implement.
-      throw new UnimplementedError();
+      return typeParameterContext.getTypeParameterType(type.paramReference);
     } else if (type.syntheticReturnType != null) {
       // TODO(paulberry): implement.
       throw new UnimplementedError();
     } else {
       DartTypeForLink getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
-          return _resolveTypeRef(type.typeArguments[i]);
+          return _resolveTypeRef(type.typeArguments[i], typeParameterContext);
         } else {
           return DynamicTypeForLink.instance;
         }
       }
       ReferenceableElementForLink element = _resolveRef(type.reference);
       return element.buildType(
           getTypeArgument, type.implicitFunctionTypeIndices);
     }
   }
 }
@@ skipping 856 matching lines @@
     implements TopLevelVariableElement {
   TopLevelVariableElementForLink(CompilationUnitElement enclosingElement,
       UnlinkedVariable unlinkedVariable)
       : super(unlinkedVariable, enclosingElement);
 
   @override
   bool get isStatic => true;
 }
 
 /**
+ * Interface representing elements which can serve as the context within which
+ * type parameter indices are interpreted.
+ */
+abstract class TypeParameterContext {
+  /**
+   * Convert the given [index] into a type parameter type.
+   */
+  TypeParameterTypeForLink getTypeParameterType(int index);
+}
+
+/**
+ * Representation of a type based on a type parameter during linking.
+ *
+ * TODO(paulberry): add more functionality as needed.
+ */
+class TypeParameterTypeForLink extends DartTypeForLink
+    implements TypeParameterType {}
+
+/**
  * Singleton element used for unresolved references.
  */
 class UndefinedElementForLink implements ReferenceableElementForLink {
   static const UndefinedElementForLink instance =
       const UndefinedElementForLink._();
 
   const UndefinedElementForLink._();
 
   @override
   ConstructorElementForLink get asConstructor => null;
@@ skipping 161 matching lines @@
 
   /**
    * Throw away any information produced by a previous call to [link].
    */
   void unlink() {
     for (LibraryElementInBuildUnit library in _librariesInBuildUnit) {
       library.unlink();
     }
   }
 }