Add ElementImpl.typeParameterContext getter.

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/token.dart';
@@ skipping 281 matching lines @@
     }
     return hasLibrarySummary(uri);
   }
 }
 
 /**
  * Builder of [Expression]s from [UnlinkedConst]s.
  */
 class _ConstExprBuilder {
   final _UnitResynthesizer resynthesizer;
-  final Element context;
+  final ElementImpl context;
   final UnlinkedConst uc;
 
-  bool _typeParameterContextReady = false;
-  TypeParameterizedElementMixin _typeParameterContext;
-
   int intPtr = 0;
   int doublePtr = 0;
   int stringPtr = 0;
   int refPtr = 0;
   final List<Expression> stack = <Expression>[];
 
   _ConstExprBuilder(this.resynthesizer, this.context, this.uc);
 
-  TypeParameterizedElementMixin get typeParameterContext {
-    if (!_typeParameterContextReady) {
-      for (Element e = context; e != null; e = e.enclosingElement) {
-        if (e is TypeParameterizedElementMixin) {
-          _typeParameterContext = e;
-          break;
-        }
-      }
-      _typeParameterContextReady = true;
-    }
-    return _typeParameterContext;
-  }
-
   Expression build() {
     if (!uc.isValidConst) {
       return AstFactory.identifier3(r'$$invalidConstExpr$$');
     }
     for (UnlinkedConstOperation operation in uc.operations) {
       switch (operation) {
         case UnlinkedConstOperation.pushNull:
           _push(AstFactory.nullLiteral());
           break;
         // bool
@@ skipping 290 matching lines @@
     if (info.element != null) {
       if (info.element is ConstructorElement) {
         constructorName = info.name;
       } else if (info.element is ClassElement) {
         constructorName = null;
       } else {
         throw new StateError('Unsupported element for invokeConstructor '
             '${info.element?.runtimeType}');
       }
       InterfaceType definingType = resynthesizer._createConstructorDefiningType(
-          typeParameterContext, info, ref.typeArguments);
+          context?.typeParameterContext, info, ref.typeArguments);
       constructorElement =
           resynthesizer._createConstructorElement(definingType, info);
       typeNode = _buildTypeAst(definingType);
     } else {
       if (info.enclosing != null) {
         if (info.enclosing.enclosing != null) {
           PrefixedIdentifier typeName = AstFactory.identifier5(
               info.enclosing.enclosing.name, info.enclosing.name);
           typeName.prefix.staticElement = info.enclosing.enclosing.element;
           typeName.identifier.staticElement = info.enclosing.element;
@@ skipping 880 matching lines @@
     return typeArguments;
   }
 }
 
 class _ResynthesizerContext implements ResynthesizerContext {
   final _UnitResynthesizer _unitResynthesizer;
 
   _ResynthesizerContext(this._unitResynthesizer);
 
   @override
-  ElementAnnotationImpl buildAnnotation(Element context, UnlinkedConst uc) {
+  ElementAnnotationImpl buildAnnotation(ElementImpl context, UnlinkedConst uc) {
     return _unitResynthesizer.buildAnnotation(context, uc);
   }
 
   @override
-  Expression buildExpression(Element context, UnlinkedConst uc) {
+  Expression buildExpression(ElementImpl context, UnlinkedConst uc) {
     return _unitResynthesizer._buildConstExpression(context, uc);
   }
 
   @override
   UnitExplicitTopLevelAccessors buildTopLevelAccessors() {
     return _unitResynthesizer.buildUnitExplicitTopLevelAccessors();
   }
 
   @override
   List<FunctionElementImpl> buildTopLevelFunctions() {
@@ skipping 134 matching lines @@
   }
 
   SummaryResynthesizer get summaryResynthesizer =>
       libraryResynthesizer.summaryResynthesizer;
 
   TypeProvider get typeProvider => summaryResynthesizer.typeProvider;
 
   /**
    * Build [ElementAnnotationImpl] for the given [UnlinkedConst].
    */
-  ElementAnnotationImpl buildAnnotation(Element context, UnlinkedConst uc) {
+  ElementAnnotationImpl buildAnnotation(ElementImpl context, UnlinkedConst uc) {
     ElementAnnotationImpl elementAnnotation = new ElementAnnotationImpl(unit);
     Expression constExpr = _buildConstExpression(context, uc);
     if (constExpr is Identifier) {
       elementAnnotation.element = constExpr.staticElement;
       elementAnnotation.annotationAst = AstFactory.annotation(constExpr);
     } else if (constExpr is InstanceCreationExpression) {
       elementAnnotation.element = constExpr.staticElement;
       Identifier typeName = constExpr.constructorName.type.name;
       SimpleIdentifier constructorName = constExpr.constructorName.name;
       if (typeName is SimpleIdentifier && constructorName != null) {
@@ skipping 1216 matching lines @@
         } else if (initializer is RedirectingConstructorInvocation) {
           SimpleIdentifier nameNode = initializer.constructorName;
           ConstructorElement element = constructors[nameNode?.name ?? ''];
           initializer.staticElement = element;
           nameNode?.staticElement = element;
         }
       }
     }
   }
 
-  Expression _buildConstExpression(Element context, UnlinkedConst uc) {
+  Expression _buildConstExpression(ElementImpl context, UnlinkedConst uc) {
     return new _ConstExprBuilder(this, context, uc).build();
   }
 
   /**
    * Return the defining type for a [ConstructorElement] by applying
    * [typeArgumentRefs] to the given linked [info].
    */
   InterfaceType _createConstructorDefiningType(
       TypeParameterizedElementMixin typeParameterContext,
       _ReferenceInfo info,
@@ skipping 39 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }