[Reapply] Pass ElementImpl as a context for resynthesizing types.

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 665 matching lines @@
   }
 
   @override
   String toString() => '$enclosingElement.$name';
 
   /**
    * Convert [typeRef] into an [InterfaceType].
    */
   InterfaceType _computeInterfaceType(EntityRef typeRef) {
     if (typeRef != null) {
-      DartType type = enclosingElement.resolveTypeRef(typeRef, this);
+      DartType type = enclosingElement.resolveTypeRef(this, typeRef);
       if (type is InterfaceType && !type.element.isEnum) {
         return type;
       }
       // In the event that the `typeRef` 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.typeProvider.objectType;
   }
 }
@@ skipping 296 matching lines @@
       }
       // TODO(paulberry): fill in other top level entities (typedefs
       // and executables).
     }
     return _containedNames.putIfAbsent(
         name, () => UndefinedElementForLink.instance);
   }
 
   /**
    * Compute the type referred to by the given linked type [slot] (interpreted
-   * relative to [typeParameterContext]).  If there is no inferred type in the
+   * in [context]).  If there is no inferred type in the
    * given slot, `dynamic` is returned.
    */
-  DartType getLinkedType(
-      int slot, TypeParameterizedElementMixin typeParameterContext);
+  DartType getLinkedType(ElementImpl context, int slot);
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   /**
    * Return the class element for the constructor referred to by the given
    * [index] in [UnlinkedUnit.references].  If the reference is unresolved,
    * return [UndefinedElementForLink.instance].
    */
   ReferenceableElementForLink resolveConstructorClassRef(int index) {
@@ skipping 51 matching lines @@
       } else {
         LibraryElementForLink dependency =
             enclosingElement._getDependency(linkedReference.dependency);
         _references[index] = dependency.getContainedName(name);
       }
     }
     return _references[index];
   }
 
   @override
-  DartType resolveTypeRef(
-      EntityRef type, TypeParameterizedElementMixin typeParameterContext,
+  DartType resolveTypeRef(ElementImpl context, EntityRef type,
       {bool defaultVoid: false,
       bool instantiateToBoundsAllowed: true,
       bool declaredType: false}) {
     if (type == null) {
       if (defaultVoid) {
         return VoidTypeImpl.instance;
       } else {
         return DynamicTypeImpl.instance;
       }
     }
     if (type.paramReference != 0) {
-      return typeParameterContext.getTypeParameterType(type.paramReference);
+      return context.typeParameterContext
+          .getTypeParameterType(type.paramReference);
     } else if (type.syntheticReturnType != null) {
       // TODO(paulberry): implement.
       throw new UnimplementedError();
     } else if (type.implicitFunctionTypeIndices.isNotEmpty) {
       // TODO(paulberry): implement.
       throw new UnimplementedError();
     } else {
       DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
-          return resolveTypeRef(type.typeArguments[i], typeParameterContext);
+          return resolveTypeRef(context, type.typeArguments[i]);
         } else if (!instantiateToBoundsAllowed) {
           // Do not allow buildType to instantiate the bounds; force dynamic.
           return DynamicTypeImpl.instance;
         } else {
           return null;
         }
       }
 
       ReferenceableElementForLink element = resolveRef(type.reference);
       return element.buildType(
@@ skipping 159 matching lines @@
       // [LinkedReference.numTypeParameters]).
       return addRawReference(element.name,
           containingReference: addReference(enclosingClass),
           kind: ReferenceKind.propertyAccessor);
     }
     // TODO(paulberry): implement other cases
     throw new UnimplementedError('${element.runtimeType}');
   }
 
   @override
-  DartType getLinkedType(
-      int slot, TypeParameterizedElementMixin typeParameterContext) {
+  DartType getLinkedType(ElementImpl context, int slot) {
     // This method should only be called on compilation units that come from
     // dependencies, never on compilation units that are part of the current
     // build unit.
     throw new StateError(
         'Linker tried to access linked type from current build unit');
   }
 
   /**
    * Perform type inference and const cycle detection on this
    * compilation unit.
@@ skipping 105 matching lines @@
     _linkedTypeRefs = new List<EntityRef>(maxLinkedTypeSlot + 1);
     for (EntityRef ref in _linkedUnit.types) {
       _linkedTypeRefs[ref.slot] = ref;
     }
   }
 
   @override
   bool get isInBuildUnit => false;
 
   @override
-  DartType getLinkedType(
-      int slot, TypeParameterizedElementMixin typeParameterContext) {
+  DartType getLinkedType(ElementImpl context, int slot) {
     if (slot < _linkedTypeRefs.length) {
-      return resolveTypeRef(_linkedTypeRefs[slot], typeParameterContext);
+      return resolveTypeRef(context, _linkedTypeRefs[slot]);
     } else {
       return DynamicTypeImpl.instance;
     }
   }
 }
 
 /**
  * Instance of [ConstNode] representing a constant constructor.
  */
 class ConstConstructorNode extends ConstNode {
@@ skipping 402 matching lines @@
 
   /**
    * If the executable element had an explicitly declared return type, return
    * it.  Otherwise return `null`.
    */
   DartType get declaredReturnType {
     if (_unlinkedExecutable.returnType == null) {
       return null;
     } else {
       return _declaredReturnType ??=
-          compilationUnit.resolveTypeRef(_unlinkedExecutable.returnType, this);
+          compilationUnit.resolveTypeRef(this, _unlinkedExecutable.returnType);
     }
   }
 
   @override
   String get displayName {
     if (_displayName == null) {
       _displayName = _unlinkedExecutable.name;
       if (_unlinkedExecutable.kind == UnlinkedExecutableKind.setter) {
         _displayName = _displayName.substring(0, _displayName.length - 1);
       }
@@ skipping 26 matching lines @@
       return _computeDefaultReturnType();
     }
     if (_inferredReturnType == null) {
       if (_unlinkedExecutable.kind == UnlinkedExecutableKind.constructor) {
         // TODO(paulberry): implement.
         throw new UnimplementedError();
       } else if (compilationUnit.isInBuildUnit) {
         _inferredReturnType = _computeDefaultReturnType();
       } else {
         _inferredReturnType = compilationUnit.getLinkedType(
-            _unlinkedExecutable.inferredReturnTypeSlot, this);
+            this, _unlinkedExecutable.inferredReturnTypeSlot);
       }
     }
     return _inferredReturnType;
   }
 
   @override
   bool get isStatic => _unlinkedExecutable.isStatic;
 
   @override
   bool get isSynthetic => false;
@@ skipping 427 matching lines @@
 
     EntityRef ref = _getNextRef();
     ReferenceableElementForLink refElement = unit.resolveRef(ref.reference);
     ConstructorElementForLink constructorElement = refElement.asConstructor;
 
     if (constructorElement != null) {
       stack.add(() {
         if (ref.typeArguments.isNotEmpty) {
           return constructorElement.enclosingClass.buildType((int i) {
             if (i < ref.typeArguments.length) {
-              return unit.resolveTypeRef(
-                  ref.typeArguments[i], function.typeParameterContext);
+              return unit.resolveTypeRef(function, ref.typeArguments[i]);
             } else {
               return null;
             }
           }, const <int>[]);
         } else {
           FunctionType rawType = StaticTypeAnalyzer
               .constructorToGenericFunctionType(constructorElement);
           FunctionType inferredType = _inferExecutableType(
               rawType,
               numNamed,
@@ skipping 179 matching lines @@
   List<String> _getNextStrings(int n) {
     List<String> result = new List<String>(n);
     for (int i = 0; i < n; i++) {
       result[i] = _getNextString();
     }
     return result;
   }
 
   DartType _getNextTypeRef() {
     EntityRef ref = _getNextRef();
-    return unit.resolveTypeRef(ref, function.typeParameterContext);
+    return unit.resolveTypeRef(function, ref);
   }
 
   List<DartType> _getTypeArguments() {
     int numTypeArguments = _getNextInt();
     List<DartType> typeArguments = new List<DartType>(numTypeArguments);
     for (int i = 0; i < numTypeArguments; i++) {
       typeArguments[i] = _getNextTypeRef();
     }
     return typeArguments;
   }
@@ skipping 336 matching lines @@
     return _implicitFunctionTypeIndices;
   }
 
   @override
   DartType get returnType {
     if (_returnType == null) {
       if (enclosingElement._unlinkedParam.type == null) {
         _returnType = DynamicTypeImpl.instance;
       } else {
         _returnType = enclosingElement.compilationUnit.resolveTypeRef(
-            enclosingElement._unlinkedParam.type, typeParameterContext);
+            enclosingElement, enclosingElement._unlinkedParam.type);
       }
     }
     return _returnType;
   }
 
   @override
   List<TypeParameterElement> get typeParameters => const [];
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
@@ skipping 294 matching lines @@
   bool get isSynthetic => false;
 
   @override
   LibraryElementForLink get library => enclosingElement.library;
 
   @override
   String get name => _unlinkedTypedef.name;
 
   @override
   DartType get returnType => _returnType ??=
-      enclosingElement.resolveTypeRef(_unlinkedTypedef.returnType, this);
+      enclosingElement.resolveTypeRef(this, _unlinkedTypedef.returnType);
 
   @override
   TypeParameterizedElementMixin get typeParameterContext => this;
 
   @override
   List<UnlinkedParam> get unlinkedParameters => _unlinkedTypedef.parameters;
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
       _unlinkedTypedef.typeParameters;
@@ skipping 972 matching lines @@
     if (_inferredType != null) {
       return _inferredType;
     } else if (_declaredType == null) {
       if (_unlinkedParam.isFunctionTyped) {
         _declaredType = new FunctionTypeImpl(
             new FunctionElementForLink_FunctionTypedParam(
                 this, _typeParameterContext, _unlinkedParam.parameters));
       } else if (_unlinkedParam.type == null) {
         if (!compilationUnit.isInBuildUnit) {
           _inferredType = compilationUnit.getLinkedType(
-              _unlinkedParam.inferredTypeSlot, _typeParameterContext);
+              this, _unlinkedParam.inferredTypeSlot);
           return _inferredType;
         } else {
           _declaredType = DynamicTypeImpl.instance;
         }
       } else {
-        _declaredType = compilationUnit.resolveTypeRef(
-            _unlinkedParam.type, _typeParameterContext);
+        _declaredType =
+            compilationUnit.resolveTypeRef(this, _unlinkedParam.type);
       }
     }
     return _declaredType;
   }
 
   @override
   void set type(DartType inferredType) {
     assert(_inferredType == null);
     _inferredType = inferredType;
   }
 
+  @override
+  TypeParameterizedElementMixin get typeParameterContext {
+    return _typeParameterContext;
+  }
+
   /**
    * Store the results of type inference for this parameter in
    * [compilationUnit].
    */
   void link(CompilationUnitElementInBuildUnit compilationUnit) {
     compilationUnit._storeLinkedType(
         _unlinkedParam.inferredTypeSlot, _inferredType, _typeParameterContext);
     compilationUnit._storeLinkedTypeError(
         _unlinkedParam.inferredTypeSlot, _inferenceError);
     if (inheritsCovariant) {
@@ skipping 954 matching lines @@
   }
 
   /**
    * If the variable has an explicitly declared return type, return it.
    * Otherwise return `null`.
    */
   DartType get declaredType {
     if (unlinkedVariable.type == null) {
       return null;
     } else {
-      return _declaredType ??= compilationUnit.resolveTypeRef(
-          unlinkedVariable.type, _typeParameterContext);
+      return _declaredType ??=
+          compilationUnit.resolveTypeRef(this, unlinkedVariable.type);
     }
   }
 
   @override
   String get displayName => unlinkedVariable.name;
 
   @override
   PropertyAccessorElementForLink_Variable get getter =>
       _getter ??= new PropertyAccessorElementForLink_Variable(this, false);
 
@@ skipping 18 matching lines @@
         try {
           new TypeInferenceDependencyWalker().walk(_typeInferenceNode);
           assert(_inferredType != null);
         } finally {
           Linker._initializerTypeInferenceCycle = null;
         }
       } else if (compilationUnit.isInBuildUnit) {
         _inferredType = DynamicTypeImpl.instance;
       } else {
         _inferredType = compilationUnit.getLinkedType(
-            unlinkedVariable.inferredTypeSlot, _typeParameterContext);
+            this, unlinkedVariable.inferredTypeSlot);
       }
     }
     return _inferredType;
   }
 
   @override
   FunctionElementForLink_Initializer get initializer {
     if (unlinkedVariable.initializer == null) {
       return null;
     } else {
@@ skipping 38 matching lines @@
   }
 
   @override
   DartType get type => declaredType ?? inferredType;
 
   @override
   void set type(DartType newType) {
     // TODO(paulberry): store inferred type.
   }
 
+  @override
+  TypeParameterizedElementMixin get typeParameterContext {
+    return _typeParameterContext;
+  }
+
   /**
    * The context in which type parameters should be interpreted, or `null` if
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }
 
 /**
  * This exception is thrown when [ExprTypeComputer] cannot inference the type.
  */
 class _InferenceFailedError {
   final String message;
 
   _InferenceFailedError(this.message);
 }