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

pkg/analyzer/lib/src/summary/resynthesize.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 summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
@@ skipping 576 matching lines @@
           TokenFactory.tokenFromType(TokenType.CLOSE_CURLY_BRACKET));
     }
   }
 
   /**
    * Convert the next reference to the [DartType] and return the AST
    * corresponding to this type.
    */
   TypeAnnotation _newTypeName() {
     EntityRef typeRef = uc.references[refPtr++];
-    DartType type = resynthesizer.buildType(context, typeRef);
+    DartType type =
+        resynthesizer.buildType(typeRef, context?.typeParameterContext);
     return _buildTypeAst(type);
   }
 
   Expression _pop() => stack.removeLast();
 
   void _push(Expression expr) {
     stack.add(expr);
   }
 
   void _pushBinary(TokenType operator) {
@@ skipping 27 matching lines @@
         constructorName = null;
       } else {
         List<Expression> arguments = _buildArguments();
         SimpleIdentifier name = AstTestFactory.identifier3(info.name);
         name.staticElement = info.element;
         name.setProperty(ARGUMENT_LIST, AstTestFactory.argumentList(arguments));
         _push(name);
         return;
       }
       InterfaceType definingType = resynthesizer._createConstructorDefiningType(
-          context, info, ref.typeArguments);
+          context?.typeParameterContext, info, ref.typeArguments);
       constructorElement =
           resynthesizer._getConstructorForInfo(definingType, info);
       typeNode = _buildTypeAst(definingType);
     } else {
       if (info.enclosing != null) {
         if (info.enclosing.enclosing != null) {
           PrefixedIdentifier typeName = AstTestFactory.identifier5(
               info.enclosing.enclosing.name, info.enclosing.name);
           typeName.prefix.staticElement = info.enclosing.enclosing.element;
           typeName.identifier.staticElement = info.enclosing.element;
@@ skipping 775 matching lines @@
     return _unitResynthesizer.parametersInheritingCovariant.contains(slot);
   }
 
   @override
   bool isInConstCycle(int slot) {
     return _unitResynthesizer.constCycles.contains(slot);
   }
 
   @override
   ConstructorElement resolveConstructorRef(
-      ElementImpl context, EntityRef entry) {
-    return _unitResynthesizer._getConstructorForEntry(context, entry);
+      TypeParameterizedElementMixin typeParameterContext, EntityRef entry) {
+    return _unitResynthesizer._getConstructorForEntry(
+        typeParameterContext, entry);
   }
 
   @override
-  DartType resolveLinkedType(ElementImpl context, int slot) {
-    return _unitResynthesizer.buildLinkedType(context, slot);
+  DartType resolveLinkedType(
+      int slot, TypeParameterizedElementMixin typeParameterContext) {
+    return _unitResynthesizer.buildLinkedType(slot, typeParameterContext);
   }
 
   @override
-  DartType resolveTypeRef(ElementImpl context, EntityRef type,
+  DartType resolveTypeRef(
+      EntityRef type, TypeParameterizedElementMixin typeParameterContext,
       {bool defaultVoid: false,
       bool instantiateToBoundsAllowed: true,
       bool declaredType: false}) {
-    return _unitResynthesizer.buildType(context, type,
+    return _unitResynthesizer.buildType(type, typeParameterContext,
         defaultVoid: defaultVoid,
         instantiateToBoundsAllowed: instantiateToBoundsAllowed,
         declaredType: declaredType);
   }
 }
 
 /**
  * An instance of [_UnitResynthesizer] is responsible for resynthesizing the
  * elements in a single unit from that unit's summary.
  */
@@ skipping 148 matching lines @@
     PropertyAccessorElementImpl_ImplicitSetter setter =
         new PropertyAccessorElementImpl_ImplicitSetter(property);
     setter.enclosingElement = property.enclosingElement;
     return setter;
   }
 
   /**
    * Build the appropriate [DartType] object corresponding to a slot id in the
    * [LinkedUnit.types] table.
    */
-  DartType buildLinkedType(ElementImpl context, int slot) {
+  DartType buildLinkedType(
+      int slot, TypeParameterizedElementMixin typeParameterContext) {
     if (slot == 0) {
       // A slot id of 0 means there is no [DartType] object to build.
       return null;
     }
     EntityRef type = linkedTypeMap[slot];
     if (type == null) {
       // A missing entry in [LinkedUnit.types] means there is no [DartType]
       // stored in this slot.
       return null;
     }
-    return buildType(context, type);
+    return buildType(type, typeParameterContext);
   }
 
   /**
    * Build a [DartType] object based on a [EntityRef].  This [DartType]
    * may refer to elements in other libraries than the library being
    * deserialized, so handles are used to avoid having to deserialize other
    * libraries in the process.
    */
-  DartType buildType(ElementImpl context, EntityRef type,
+  DartType buildType(
+      EntityRef type, TypeParameterizedElementMixin typeParameterContext,
       {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 context.typeParameterContext
-          .getTypeParameterType(type.paramReference);
+      return typeParameterContext.getTypeParameterType(type.paramReference);
     } else if (type.entityKind == EntityRefKind.genericFunctionType) {
       GenericFunctionTypeElement element =
-          new GenericFunctionTypeElementImpl.forSerialized(context, type);
+          new GenericFunctionTypeElementImpl.forSerialized(
+              type, typeParameterContext);
       return element.type;
     } else if (type.syntheticReturnType != null) {
-      FunctionElementImpl element = new FunctionElementImpl_forLUB(
-          unit, context.typeParameterContext, type);
+      FunctionElementImpl element =
+          new FunctionElementImpl_forLUB(unit, typeParameterContext, type);
       return element.type;
     } else {
       DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
-          return buildType(context, type.typeArguments[i],
+          return buildType(type.typeArguments[i], typeParameterContext,
               declaredType: declaredType);
         } else {
           return DynamicTypeImpl.instance;
         }
       }
 
       _ReferenceInfo referenceInfo = getReferenceInfo(type.reference);
       if (declaredType && !referenceInfo.isDeclarableType) {
         return DynamicTypeImpl.instance;
       }
@@ skipping 236 matching lines @@
 
   Expression _buildConstExpression(ElementImpl context, UnlinkedExpr uc) {
     return new _ConstExprBuilder(this, context, uc).build();
   }
 
   /**
    * Return the defining type for a [ConstructorElement] by applying
    * [typeArgumentRefs] to the given linked [info].  Return [DynamicTypeImpl]
    * if the [info] is unresolved.
    */
-  DartType _createConstructorDefiningType(ElementImpl context,
-      _ReferenceInfo info, List<EntityRef> typeArgumentRefs) {
+  DartType _createConstructorDefiningType(
+      TypeParameterizedElementMixin typeParameterContext,
+      _ReferenceInfo info,
+      List<EntityRef> typeArgumentRefs) {
     bool isClass = info.element is ClassElement;
     _ReferenceInfo classInfo = isClass ? info : info.enclosing;
     if (classInfo == null) {
       return DynamicTypeImpl.instance;
     }
-    List<DartType> typeArguments =
-        typeArgumentRefs.map((t) => buildType(context, t)).toList();
+    List<DartType> typeArguments = typeArgumentRefs
+        .map((t) => buildType(t, typeParameterContext))
+        .toList();
     return classInfo.buildType(true, typeArguments.length, (i) {
       if (i < typeArguments.length) {
         return typeArguments[i];
       } else {
         return DynamicTypeImpl.instance;
       }
     }, const <int>[]);
   }
 
   /**
    * Return the [ConstructorElement] corresponding to the given [entry].
    */
   ConstructorElement _getConstructorForEntry(
-      ElementImpl context, EntityRef entry) {
+      TypeParameterizedElementMixin typeParameterContext, EntityRef entry) {
     _ReferenceInfo info = getReferenceInfo(entry.reference);
-    DartType type =
-        _createConstructorDefiningType(context, info, entry.typeArguments);
+    DartType type = _createConstructorDefiningType(
+        typeParameterContext, info, entry.typeArguments);
     if (type is InterfaceType) {
       return _getConstructorForInfo(type, info);
     }
     return null;
   }
 
   /**
    * Return the [ConstructorElement] corresponding to the given linked [info],
    * using the [classType] which has already been computed (e.g. by
    * [_createConstructorDefiningType]).  Both cases when [info] is a
@@ skipping 22 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }