Revert "Pass ElementImpl as a context for resynthesizing types."

pkg/analyzer/lib/src/dart/element/element.dart

 // Copyright (c) 2014, 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.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 706 matching lines @@
       }
     }
     return false;
   }
 
   @override
   List<InterfaceType> get interfaces {
     if (_unlinkedClass != null && _interfaces == null) {
       ResynthesizerContext context = enclosingUnit.resynthesizerContext;
       _interfaces = _unlinkedClass.interfaces
-          .map((EntityRef t) => context.resolveTypeRef(this, t))
+          .map((EntityRef t) => context.resolveTypeRef(t, this))
           .where(_isClassInterfaceType)
           .toList(growable: false);
     }
     return _interfaces ?? const <InterfaceType>[];
   }
 
   void set interfaces(List<InterfaceType> interfaces) {
     _assertNotResynthesized(_unlinkedClass);
     _interfaces = interfaces;
   }
@@ skipping 86 matching lines @@
   void set mixinApplication(bool isMixinApplication) {
     _assertNotResynthesized(_unlinkedClass);
     setModifier(Modifier.MIXIN_APPLICATION, isMixinApplication);
   }
 
   @override
   List<InterfaceType> get mixins {
     if (_unlinkedClass != null && _mixins == null) {
       ResynthesizerContext context = enclosingUnit.resynthesizerContext;
       _mixins = _unlinkedClass.mixins
-          .map((EntityRef t) => context.resolveTypeRef(this, t))
+          .map((EntityRef t) => context.resolveTypeRef(t, this))
           .where(_isClassInterfaceType)
           .toList(growable: false);
     }
     return _mixins ?? const <InterfaceType>[];
   }
 
   void set mixins(List<InterfaceType> mixins) {
     _assertNotResynthesized(_unlinkedClass);
     _mixins = mixins;
   }
@@ skipping 13 matching lines @@
       return _unlinkedClass.nameOffset;
     }
     return offset;
   }
 
   @override
   InterfaceType get supertype {
     if (_unlinkedClass != null && _supertype == null) {
       if (_unlinkedClass.supertype != null) {
         DartType type = enclosingUnit.resynthesizerContext
-            .resolveTypeRef(this, _unlinkedClass.supertype);
+            .resolveTypeRef(_unlinkedClass.supertype, this);
         if (_isClassInterfaceType(type)) {
           _supertype = type;
         } else {
           _supertype = context.typeProvider.objectType;
         }
       } else if (_unlinkedClass.hasNoSupertype) {
         return null;
       } else {
         _supertype = context.typeProvider.objectType;
       }
@@ skipping 2993 matching lines @@
     this._parameters = parameters;
   }
 
   @override
   DartType get returnType {
     if (serializedExecutable != null &&
         _declaredReturnType == null &&
         _returnType == null) {
       bool isSetter =
           serializedExecutable.kind == UnlinkedExecutableKind.setter;
-      _returnType = enclosingUnit.resynthesizerContext
-          .resolveLinkedType(this, serializedExecutable.inferredReturnTypeSlot);
+      _returnType = enclosingUnit.resynthesizerContext.resolveLinkedType(
+          serializedExecutable.inferredReturnTypeSlot, typeParameterContext);
       _declaredReturnType = enclosingUnit.resynthesizerContext.resolveTypeRef(
-          this, serializedExecutable.returnType,
+          serializedExecutable.returnType, typeParameterContext,
           defaultVoid: isSetter && context.analysisOptions.strongMode,
           declaredType: true);
     }
     return _returnType ?? _declaredReturnType;
   }
 
   void set returnType(DartType returnType) {
     _assertNotResynthesized(serializedExecutable);
     _returnType = _checkElementOfType(returnType);
   }
@@ skipping 669 matching lines @@
   }
 
   @override
   void set parameters(List<ParameterElement> parameters) {
     assert(false);
   }
 
   @override
   DartType get returnType {
     return _returnType ??= enclosingUnit.resynthesizerContext
-        .resolveTypeRef(this, _entityRef.syntheticReturnType);
+        .resolveTypeRef(_entityRef.syntheticReturnType, typeParameterContext);
   }
 
   @override
   void set returnType(DartType returnType) {
     assert(false);
   }
 
   @override
   FunctionType get type {
     return _type ??=
@@ skipping 143 matching lines @@
         (parameter as ParameterElementImpl).enclosingElement = this;
       }
     }
     this._parameters = parameters;
   }
 
   @override
   DartType get returnType {
     if (_unlinkedTypedef != null && _returnType == null) {
       _returnType = enclosingUnit.resynthesizerContext.resolveTypeRef(
-          this, _unlinkedTypedef.returnType,
+          _unlinkedTypedef.returnType, this,
           declaredType: true);
     }
     return _returnType;
   }
 
   void set returnType(DartType returnType) {
     _assertNotResynthesized(_unlinkedTypedef);
     _returnType = _checkElementOfType(returnType);
   }
 
@@ skipping 102 matching lines @@
  */
 class GenericFunctionTypeElementImpl extends ElementImpl
     with TypeParameterizedElementMixin
     implements GenericFunctionTypeElement {
   /**
    * The unlinked representation of the generic function type in the summary.
    */
   EntityRef _entityRef;
 
   /**
+   * The enclosing type parameter context.
+   */
+  TypeParameterizedElementMixin _typeParameterContext;
+
+  /**
    * The declared return type of the function.
    */
   DartType _returnType;
 
   /**
    * The elements representing the parameters of the function.
    */
   List<ParameterElement> _parameters;
 
   /**
    * The type defined by this element.
    */
   FunctionType _type;
 
   /**
    * Initialize a newly created function element to have no name and the given
    * [nameOffset]. This is used for function expressions, that have no name.
    */
   GenericFunctionTypeElementImpl.forOffset(int nameOffset)
       : super("", nameOffset);
 
   /**
    * Initialize from serialized information.
    */
   GenericFunctionTypeElementImpl.forSerialized(
-      ElementImpl enclosingElement, this._entityRef)
-      : super.forSerialized(enclosingElement);
+      this._entityRef, this._typeParameterContext)
+      : super.forSerialized(null);
 
   @override
-  TypeParameterizedElementMixin get enclosingTypeParameterContext {
-    return _enclosingElement.typeParameterContext;
-  }
+  TypeParameterizedElementMixin get enclosingTypeParameterContext =>
+      _typeParameterContext ??
+      (enclosingElement as ElementImpl).typeParameterContext;
 
   @override
   String get identifier => '-';
 
   @override
   ElementKind get kind => ElementKind.GENERIC_FUNCTION_TYPE;
 
   @override
   List<ParameterElement> get parameters {
     if (_entityRef != null) {
@@ skipping 12 matching lines @@
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
   @override
   DartType get returnType {
     if (_entityRef != null && _returnType == null) {
       _returnType = enclosingUnit.resynthesizerContext.resolveTypeRef(
-          this, _entityRef.syntheticReturnType,
+          _entityRef.syntheticReturnType, typeParameterContext,
           defaultVoid: false, declaredType: true);
     }
     return _returnType;
   }
 
   /**
    * Set the return type defined by this function type element to the given
    * [returnType].
    */
   void set returnType(DartType returnType) {
@@ skipping 153 matching lines @@
   TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
 
   @override
   CompilationUnitElementImpl get enclosingUnit =>
       _enclosingElement as CompilationUnitElementImpl;
 
   @override
   GenericFunctionTypeElement get function {
     if (_function == null && _unlinkedTypedef != null) {
       DartType type = enclosingUnit.resynthesizerContext.resolveTypeRef(
-          this, _unlinkedTypedef.returnType,
+          _unlinkedTypedef.returnType, this,
           declaredType: true);
       if (type is FunctionType) {
         Element element = type.element;
         if (element is GenericFunctionTypeElement) {
           (element as GenericFunctionTypeElementImpl).enclosingElement = this;
           _function = element;
         }
       }
     }
     return _function;
@@ skipping 2157 matching lines @@
     int offset = super.nameOffset;
     if (offset == 0 && _unlinkedVariable != null) {
       return _unlinkedVariable.nameOffset;
     }
     return offset;
   }
 
   @override
   DartType get type {
     if (_unlinkedVariable != null && _declaredType == null && _type == null) {
-      _type = enclosingUnit.resynthesizerContext
-          .resolveLinkedType(this, _unlinkedVariable.inferredTypeSlot);
-      declaredType = enclosingUnit.resynthesizerContext
-          .resolveTypeRef(this, _unlinkedVariable.type, declaredType: true);
+      _type = enclosingUnit.resynthesizerContext.resolveLinkedType(
+          _unlinkedVariable.inferredTypeSlot, typeParameterContext);
+      declaredType = enclosingUnit.resynthesizerContext.resolveTypeRef(
+          _unlinkedVariable.type, typeParameterContext,
+          declaredType: true);
     }
     return super.type;
   }
 
   @override
   void set type(DartType type) {
     _assertNotResynthesized(_unlinkedVariable);
     _type = _checkElementOfType(type);
   }
 
@@ skipping 481 matching lines @@
         List<ParameterElement> subParameters = ParameterElementImpl
             .resynthesizeList(_unlinkedParam.parameters, this,
                 synthetic: isSynthetic);
         if (isSynthetic) {
           parameterTypeElement.parameters = subParameters;
         } else {
           _parameters = subParameters;
           parameterTypeElement.shareParameters(subParameters);
         }
         parameterTypeElement.returnType = enclosingUnit.resynthesizerContext
-            .resolveTypeRef(this, _unlinkedParam.type);
+            .resolveTypeRef(_unlinkedParam.type, typeParameterContext);
         FunctionTypeImpl parameterType =
             new FunctionTypeImpl.elementWithNameAndArgs(parameterTypeElement,
                 null, typeParameterContext.allTypeParameterTypes, false);
         parameterTypeElement.type = parameterType;
         _type = parameterType;
       } else {
-        _type = enclosingUnit.resynthesizerContext
-            .resolveLinkedType(this, _unlinkedParam.inferredTypeSlot);
-        declaredType = enclosingUnit.resynthesizerContext
-            .resolveTypeRef(this, _unlinkedParam.type, declaredType: true);
+        _type = enclosingUnit.resynthesizerContext.resolveLinkedType(
+            _unlinkedParam.inferredTypeSlot, typeParameterContext);
+        declaredType = enclosingUnit.resynthesizerContext.resolveTypeRef(
+            _unlinkedParam.type, typeParameterContext,
+            declaredType: true);
       }
     }
   }
 
   /**
    * Create and return [ParameterElement]s for the given [unlinkedParameters].
    */
   static List<ParameterElement> resynthesizeList(
       List<UnlinkedParam> unlinkedParameters, ElementImpl enclosingElement,
       {bool synthetic: false}) {
@@ skipping 476 matching lines @@
   /**
    * Initialize using the given serialized information.
    */
   PropertyInducingElementImpl.forSerialized(
       UnlinkedVariable unlinkedVariable, ElementImpl enclosingElement)
       : super.forSerialized(unlinkedVariable, enclosingElement);
 
   @override
   DartType get propagatedType {
     if (_unlinkedVariable != null && _propagatedType == null) {
-      _propagatedType = enclosingUnit.resynthesizerContext
-          .resolveLinkedType(this, _unlinkedVariable.propagatedTypeSlot);
+      _propagatedType = enclosingUnit.resynthesizerContext.resolveLinkedType(
+          _unlinkedVariable.propagatedTypeSlot, typeParameterContext);
     }
     return _propagatedType;
   }
 
   void set propagatedType(DartType propagatedType) {
     _assertNotResynthesized(_unlinkedVariable);
     _propagatedType = _checkElementOfType(propagatedType);
   }
 
   @override
@@ skipping 54 matching lines @@
   /**
    * Return `true` if the given const constructor [slot] is a part of a cycle.
    */
   bool isInConstCycle(int slot);
 
   /**
    * Resolve an [EntityRef] into a constructor.  If the reference is
    * unresolved, return `null`.
    */
   ConstructorElement resolveConstructorRef(
-      ElementImpl context, EntityRef entry);
+      TypeParameterizedElementMixin typeParameterContext, EntityRef entry);
 
   /**
    * Build the appropriate [DartType] object corresponding to a slot id in the
    * [LinkedUnit.types] table.
    */
-  DartType resolveLinkedType(ElementImpl context, int slot);
+  DartType resolveLinkedType(
+      int slot, TypeParameterizedElementMixin typeParameterContext);
 
   /**
    * 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?
    */
-  DartType resolveTypeRef(ElementImpl context, EntityRef type,
+  DartType resolveTypeRef(
+      EntityRef type, TypeParameterizedElementMixin typeParameterContext,
       {bool defaultVoid: false,
       bool instantiateToBoundsAllowed: true,
       bool declaredType: false});
 }
 
 /**
  * A concrete implementation of a [ShowElementCombinator].
  */
 class ShowElementCombinatorImpl implements ShowElementCombinator {
   /**
@@ skipping 181 matching lines @@
         super(name, -1) {
     isSynthetic = true;
   }
 
   DartType get bound {
     if (_unlinkedTypeParam != null) {
       if (_unlinkedTypeParam.bound == null) {
         return null;
       }
       return _bound ??= enclosingUnit.resynthesizerContext.resolveTypeRef(
-          this, _unlinkedTypeParam.bound,
+          _unlinkedTypeParam.bound, enclosingElement,
           instantiateToBoundsAllowed: false, declaredType: true);
     }
     return _bound;
   }
 
   void set bound(DartType bound) {
     _assertNotResynthesized(_unlinkedTypeParam);
     _bound = _checkElementOfType(bound);
   }
 
@@ skipping 502 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }