Create a TypeDefiningElement interface.

pkg/analyzer/lib/src/generated/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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
@@ skipping 110 matching lines @@
     buffer.write('...');
   }
 
   @override
   TypeImpl pruned(List<FunctionTypeAliasElement> prune) => this;
 }
 
 /**
  * An element that represents a class.
  */
-abstract class ClassElement implements Element {
+abstract class ClassElement implements TypeDefiningElement {
   /**
    * An empty list of class elements.
    */
   static const List<ClassElement> EMPTY_LIST = const <ClassElement>[];
 
   /**
    * Return a list containing all of the accessors (getters and setters)
    * declared in this class.
    */
   List<PropertyAccessorElement> get accessors;
@@ skipping 119 matching lines @@
    * is possible for it to be semantically invalid. In particular, it is not
    * safe to assume that the inheritance structure of a class does not contain a
    * cycle. Clients that traverse the inheritance structure must explicitly
    * guard against infinite loops.
    */
   InterfaceType get supertype;
 
   /**
    * Return the type defined by the class.
    */
+  @override

[Brian Wilkerson, 2015/06/08 18:22:24]

We generally remove the comments for overriding methods unless they contain new
information.

[Paul Berry, 2015/06/08 18:26:24]

Done.

   InterfaceType get type;
 
   /**
    * Return a list containing all of the type parameters declared for this
    * class.
    */
   List<TypeParameterElement> get typeParameters;
 
   /**
    * Return the unnamed constructor declared in this class, or `null` if this
@@ skipping 1866 matching lines @@
   }
 
   @override
   DefaultFormalParameter computeNode() =>
       getNodeMatching((node) => node is DefaultFormalParameter);
 }
 
 /**
  * The synthetic element representing the declaration of the type `dynamic`.
  */
-class DynamicElementImpl extends ElementImpl {
+class DynamicElementImpl extends ElementImpl implements TypeDefiningElement {
   /**
    * Return the unique instance of this class.
    */
   static DynamicElementImpl get instance =>
       DynamicTypeImpl.instance.element as DynamicElementImpl;
 
   /**
    * The type defined by this element.
    */
+  @override
   DynamicTypeImpl type;
 
   /**
    * Initialize a newly created instance of this class. Instances of this class
    * should <b>not</b> be created except as part of creating the type associated
    * with this element. The single instance of this class should be accessed
    * through the method [getInstance].
    */
   DynamicElementImpl() : super(Keyword.DYNAMIC.syntax, -1) {
     setModifier(Modifier.SYNTHETIC, true);
@@ skipping 2187 matching lines @@
    * Return the type resulting from substituting the given [argumentTypes] for
    * this type's parameters. This is fully equivalent to
    * `substitute(argumentTypes, getTypeArguments())`.
    */
   FunctionType substitute3(List<DartType> argumentTypes);
 }
 
 /**
  * A function type alias (`typedef`).
  */
-abstract class FunctionTypeAliasElement implements Element {
+abstract class FunctionTypeAliasElement implements TypeDefiningElement {
   /**
    * An empty array of type alias elements.
    */
   static List<FunctionTypeAliasElement> EMPTY_LIST =
       new List<FunctionTypeAliasElement>(0);
 
   /**
    * Return the compilation unit in which this type alias is defined.
    */
   @override
   CompilationUnitElement get enclosingElement;
 
   /**
    * Return a list containing all of the parameters defined by this type alias.
    */
   List<ParameterElement> get parameters;
 
   /**
    * Return the return type defined by this type alias.
    */
   DartType get returnType;
 
   /**
    * Return the type of function defined by this type alias.
    */
+  @override
   FunctionType get type;
 
   /**
    * Return a list containing all of the type parameters defined for this type.
    */
   List<TypeParameterElement> get typeParameters;
 
   /**
    * Return the resolved function type alias node that declares this element.
    *
@@ skipping 5207 matching lines @@
 
   @override
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
 
   @override
   VariableDeclaration computeNode() =>
       getNodeMatching((node) => node is VariableDeclaration);
 }
 
 /**
+ * An element that defines a type.
+ */
+abstract class TypeDefiningElement implements Element {
+  /**
+   * Return the type defined by this element.
+   */
+  DartType get type;
+}
+
+/**
  * The abstract class `TypeImpl` implements the behavior common to objects
  * representing the declared type of elements in the element model.
  */
 abstract class TypeImpl implements DartType {
   /**
    * An empty list of types.
    */
   @deprecated // Use DartType.EMPTY_LIST
   static const List<DartType> EMPTY_ARRAY = const <DartType>[];
 
@@ skipping 803 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }