Only ClassElementImpl has TypeParameterizedElementMixin.

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 17 matching lines @@
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/task/dart.dart';
 
 /**
  * A concrete implementation of a [ClassElement].
  */
 abstract class AbstractClassElementImpl extends ElementImpl
-    with TypeParameterizedElementMixin
     implements ClassElement {
   /**
    * A list containing all of the accessors (getters and setters) contained in
    * this class.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElement.EMPTY_LIST;
 
   /**
    * A list containing all of the fields contained in this class.
    */
   List<FieldElement> _fields = FieldElement.EMPTY_LIST;
 
   /**
-   * The superclass of the class, or `null` if the class does not have an
-   * explicit superclass.
-   */
-  @override
-  InterfaceType _supertype;
-
-  /**
    * The type defined by the class.
    */
   @override
   InterfaceType type;
 
   /**
    * Initialize a newly created class element to have the given [name] at the
    * given [offset] in the file that contains the declaration of this element.
    */
   AbstractClassElementImpl(String name, int offset) : super(name, offset);
@@ skipping 20 matching lines @@
     for (PropertyAccessorElement accessor in accessors) {
       (accessor as PropertyAccessorElementImpl).enclosingElement = this;
     }
     this._accessors = accessors;
   }
 
   @override
   String get displayName => name;
 
   @override
-  TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
-
-  @override
   List<FieldElement> get fields => _fields;
 
   /**
    * Set the fields contained in this class to the given [fields].
    */
   void set fields(List<FieldElement> fields) {
     for (FieldElement field in fields) {
       (field as FieldElementImpl).enclosingElement = this;
     }
     this._fields = fields;
   }
 
   @override
   bool get isEnum;
 
   @override
   ElementKind get kind => ElementKind.CLASS;
 
-  /**
-   * Return resynthesized type parameter elements.
-   */
-  List<TypeParameterElement> get resynthesizedTypeParameters {
-    return super.typeParameters;
-  }
-
-  @override
-  TypeParameterizedElementMixin get typeParameterContext => this;
-
-  @override
-  List<UnlinkedTypeParam> get unlinkedTypeParams => const <UnlinkedTypeParam>[];
-
   @override
   accept(ElementVisitor visitor) => visitor.visitClassElement(this);
 
   @override
   NamedCompilationUnitMember computeNode() {
     if (isEnum) {
       return getNodeMatching((node) => node is EnumDeclaration);
     } else {
       return getNodeMatching(
           (node) => node is ClassDeclaration || node is ClassTypeAlias);
@@ skipping 295 matching lines @@
   /**
    * Initialize a newly created pair to have both the [staticElement] and the
    * [propagatedElement].
    */
   AuxiliaryElements(this.staticElement, this.propagatedElement);
 }
 
 /**
  * An [AbstractClassElementImpl] which is a class.
  */
-class ClassElementImpl extends AbstractClassElementImpl {
+class ClassElementImpl extends AbstractClassElementImpl
+    with TypeParameterizedElementMixin {
   /**
    * The unlinked representation of the class in the summary.
    */
   final UnlinkedClass _unlinkedClass;
 
   /**
    * A list containing all of the type parameters defined for this class.
    */
   List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
 
   /**
+   * The superclass of the class, or `null` for [Object].
+   */
+  InterfaceType _supertype;
+
+  /**
    * A list containing all of the mixins that are applied to the class being
    * extended in order to derive the superclass of this class.
    */
   List<InterfaceType> _mixins;
 
   /**
    * A list containing all of the interfaces that are implemented by this class.
    */
   List<InterfaceType> _interfaces;
 
@@ skipping 152 matching lines @@
           assert(false);
           return false;
         }
         nearestNonMixinClass = nearestNonMixinClass.supertype.element;
       }
     }
     return !nearestNonMixinClass.constructors.any(isSuperConstructorAccessible);
   }
 
   @override
+  TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
+
+  @override
   bool get hasNonFinalField {
     List<ClassElement> classesToVisit = new List<ClassElement>();
     HashSet<ClassElement> visitedClasses = new HashSet<ClassElement>();
     classesToVisit.add(this);
     while (!classesToVisit.isEmpty) {
       ClassElement currentElement = classesToVisit.removeAt(0);
       if (visitedClasses.add(currentElement)) {
         // check fields
         for (FieldElement field in currentElement.fields) {
           if (!field.isFinal &&
@@ skipping 199 matching lines @@
     }
     return _supertype;
   }
 
   void set supertype(InterfaceType supertype) {
     assert(_unlinkedClass == null);
     _supertype = supertype;
   }
 
   @override
+  TypeParameterizedElementMixin get typeParameterContext => this;
+
+  @override
   List<TypeParameterElement> get typeParameters {
     if (_unlinkedClass != null) {
-      return resynthesizedTypeParameters;
+      return super.typeParameters;
     }
     return _typeParameters;
   }
 
   /**
    * Set the type parameters defined for this class to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
     assert(_unlinkedClass == null);
@@ skipping 7091 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }