Add ElementImpl.typeParameterContext getter.

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 456 matching lines @@
 
   @override
   int get nameOffset {
     if (_unlinkedClass != null) {
       return _unlinkedClass.nameOffset;
     }
     return super.nameOffset;
   }
 
   @override
+  TypeParameterizedElementMixin get typeParameterContext => this;
+
+  @override
   List<TypeParameterElement> get typeParameters {
     if (_unlinkedClass != null) {
       return super.typeParameters;
     }
     return _typeParameters;
   }
 
   /**
    * Set the type parameters defined for this class to the given
    * [typeParameters].
@@ skipping 774 matching lines @@
     for (int i = 0; i < functions.length; i++) {
       if (functions[i].name == FunctionElement.LOAD_LIBRARY_NAME) {
         return true;
       }
     }
     return false;
   }
 
   @override
   String get identifier => source.encoding;
+
   @override
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
-

[Paul Berry, 2016/05/25 17:16:52]

Nit: keep this blank line.

   @override

[Brian Wilkerson, 2016/05/25 17:18:47]

Strange to have the blank line go away. Is that the formatter or the sorter?

[scheglov, 2016/05/25 17:26:59]

It might be just me.
Fixed.

   List<ElementAnnotation> get metadata {
     if (_unlinkedPart != null) {
       return _metadata ??= _buildAnnotations(
           library.definingCompilationUnit as CompilationUnitElementImpl,
           _unlinkedPart.annotations);
     }
     return super.metadata;
   }
 
   @override
@@ skipping 41 matching lines @@
    * given [typeAliases].
    */
   void set typeAliases(List<FunctionTypeAliasElement> typeAliases) {
     for (FunctionTypeAliasElement typeAlias in typeAliases) {
       (typeAlias as FunctionTypeAliasElementImpl).enclosingElement = this;
     }
     this._typeAliases = typeAliases;
   }
 
   @override
+  TypeParameterizedElementMixin get typeParameterContext => null;
+
+  @override
   List<ClassElement> get types => _types;
 
   /**
    * Set the types contained in this compilation unit to the given [types].
    */
   void set types(List<ClassElement> types) {
     for (ClassElement type in types) {
       // Another implementation of ClassElement is _DeferredClassElement,
       // which is used to resynthesize classes lazily. We cannot cast it
       // to ClassElementImpl, and it already can provide correct values of the
@@ skipping 992 matching lines @@
     return _enclosingElement.source;
   }
 
   /**
    * Set whether this element is synthetic.
    */
   void set synthetic(bool isSynthetic) {
     setModifier(Modifier.SYNTHETIC, isSynthetic);
   }
 
+  /**
+   * Return the context to resolve type parameters in.

[Paul Berry, 2016/05/25 17:16:52]

Comment should specify that `null` will be returned if neither this element nor
any of its ancestors is of a kind that can declare type parameters.

[scheglov, 2016/05/25 17:26:59]

Done.

+   */
+  TypeParameterizedElementMixin get typeParameterContext {
+    return _enclosingElement?.typeParameterContext;
+  }
+
   @override
   CompilationUnit get unit => context.resolveCompilationUnit(source, library);
 
   @override
   bool operator ==(Object object) {
     if (identical(this, object)) {
       return true;
     }
     return object is Element &&
         object.kind == kind &&
@@ skipping 622 matching lines @@
    * [parameters].
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
   @override
+  TypeParameterizedElementMixin get typeParameterContext => this;
+
+  @override
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   /**
    * Set the type parameters defined by this executable element to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
     for (TypeParameterElement parameter in typeParameters) {
       (parameter as TypeParameterElementImpl).enclosingElement = this;
     }
@@ skipping 385 matching lines @@
       : super("", -1) {
     synthetic = true;
     this.returnType = returnType;
     this.parameters = parameters;
 
     type = new FunctionTypeImpl(this);
   }
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext {
-    Element enclosingElement = this.enclosingElement;
-    if (enclosingElement is TypeParameterizedElementMixin) {
-      return enclosingElement;
-    }
-    return null;
+    return (enclosingElement as ElementImpl).typeParameterContext;
   }
 
   @override
   String get identifier {
     String identifier = super.identifier;
     if (!isStatic) {
       identifier += "@$nameOffset";
     }
     return identifier;
   }
@@ skipping 205 matching lines @@
   void set parameters(List<ParameterElement> parameters) {
     if (parameters != null) {
       for (ParameterElement parameter in parameters) {
         (parameter as ParameterElementImpl).enclosingElement = this;
       }
     }
     this._parameters = parameters;
   }
 
   @override
+  TypeParameterizedElementMixin get typeParameterContext => this;
+
+  @override
   List<TypeParameterElement> get typeParameters {
     if (_unlinkedTypedef != null) {
       return super.typeParameters;
     }
     return _typeParameters;
   }
 
   /**
    * Set the type parameters defined for this type to the given
    * [typeParameters].
@@ skipping 2434 matching lines @@
     if (serializedExecutable != null && isSetter) {
       String name = serializedExecutable.name;
       assert(name.endsWith('='));
       return name.substring(0, name.length - 1);
     }
     return super.displayName;
   }
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext {
-    Element enclosingElement = this.enclosingElement;
-    if (enclosingElement is TypeParameterizedElementMixin) {
-      return enclosingElement;
-    }
-    return null;
+    return (enclosingElement as ElementImpl).typeParameterContext;
   }
 
   /**
    * Set whether this accessor is a getter.
    */
   void set getter(bool isGetter) {
     assert(serializedExecutable == null);
     setModifier(Modifier.GETTER, isGetter);
   }
 
@@ skipping 138 matching lines @@
       : super.forSerialized(unlinkedVariable, enclosingElement);
 }
 
 /**
  * The context in which elements are resynthesized.
  */
 abstract class ResynthesizerContext {
   /**
    * Build [ElementAnnotationImpl] for the given [UnlinkedConst].
    */
-  ElementAnnotationImpl buildAnnotation(Element context, UnlinkedConst uc);
+  ElementAnnotationImpl buildAnnotation(ElementImpl context, UnlinkedConst uc);
 
   /**
    * Build [Expression] for the given [UnlinkedConst].
    */
-  Expression buildExpression(Element context, UnlinkedConst uc);
+  Expression buildExpression(ElementImpl context, UnlinkedConst uc);
 
   /**
    * Build explicit top-level property accessors.
    */
   UnitExplicitTopLevelAccessors buildTopLevelAccessors();
 
   /**
    * Build top-level functions.
    */
   List<FunctionElementImpl> buildTopLevelFunctions();
@@ skipping 632 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }