Prepare for decoupling analyzer ASTs from element model.

pkg/analyzer/lib/dart/element/type.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.
 
 /**
  * Defines the type model. The type model is part of the
  * [element model](element.dart) in that most types are defined by Dart code
  * (the types `dynamic` and `void` being the notable exceptions). All types are
  * represented by an instance of a subclass of [DartType].
  *
  * Other than `dynamic` and `void`, all of the types define either the interface
  * defined by a class (an instance of [InterfaceType]) or the type of a function
  * (an instance of [FunctionType]).
  *
  * We make a distinction between the declaration of a class (a [ClassElement])
  * and the type defined by that class (an [InterfaceType]). The biggest reason
  * for the distinction is to allow us to more cleanly represent the distinction
  * between type parameters and type arguments. For example, if we define a class
  * as `class Pair<K, V> {}`, the declarations of `K` and `V` represent type
  * parameters. But if we declare a variable as `Pair<String, int> pair;` the
  * references to `String` and `int` are type arguments.
  */
 library analyzer.dart.element.type;
 
+import 'package:analyzer/dart/ast/resolution_base_classes.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart' show InterfaceTypeImpl;
 import 'package:analyzer/src/generated/type_system.dart' show TypeSystem;
 
 /**
  * The type associated with elements in the element model.
  *
  * Clients may not extend, implement or mix-in this class.
  */
-abstract class DartType {
+abstract class DartType implements ResolutionType {
   /**
    * An empty list of types.
    */
   static const List<DartType> EMPTY_LIST = const <DartType>[];
 
   /**
    * Return the name of this type as it should appear when presented to users in
    * contexts such as error messages.
    */
   String get displayName;
@@ skipping 646 matching lines @@
  * The type introduced by a type parameter.
  *
  * Clients may not extend, implement or mix-in this class.
  */
 abstract class TypeParameterType implements DartType {
   /**
    * An empty list of type parameter types.
    */
   static const List<TypeParameterType> EMPTY_LIST = const <TypeParameterType>[];
 
-  @override
-  TypeParameterElement get element;
-
   /**
    * Return the type representing the bound associated with this parameter,
    * or `dynamic` if there was no explicit bound.
    */
   DartType get bound;
 
   /**
    * An object that can be used to identify this type parameter with `==`.
    *
    * Depending on the use, [bound] may also need to be taken into account.
    * A given type parameter, it may have different bounds in different scopes.
    * Always consult the bound if that could be relevant.
    */
   ElementLocation get definition;
+
+  @override
+  TypeParameterElement get element;
 }