Move computeType to TypedElement and TypeDeclarationElement.

pkg/compiler/lib/src/elements/elements.dart

 // Copyright (c) 2012, 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 elements;
 
 
 import '../constants/expressions.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 171 matching lines @@
  * reuse elements between compilations.  So to keep things simple, it
  * is best if the backends avoid setting state directly in elements.
  * It is better to keep such state in a table on the side.
  */
 abstract class Element implements Entity {
   String get name;
   ElementKind get kind;
   Element get enclosingElement;
   Link<MetadataAnnotation> get metadata;
 
-  /// Do not use [computeType] outside of the resolver; instead retrieve the
-  /// type from the corresponding field:
-  /// - `type` for fields, variables, type variable, and function elements.
-  /// - `thisType` or `rawType` for [TypeDeclarationElement]s (classes and
-  ///    typedefs), depending on the use case.
-  /// Trying to access a type that has not been computed in resolution is an
-  /// error and calling [computeType] covers that error.
-  /// This method will go away!
-  @deprecated DartType computeType(Compiler compiler);
-
   /// `true` if this element is a library.
   bool get isLibrary;
 
   /// `true` if this element is a compilation unit.
   bool get isCompilationUnit;
 
   /// `true` if this element is defines the scope of prefix used by one or
   /// more import declarations.
   bool get isPrefix;
 
@@ skipping 871 matching lines @@
 }
 
 /**
  * A synthetic element which holds a getter and/or a setter.
  *
  * This element unifies handling of fields and getters/setters.  When
  * looking at code like "foo.x", we don't have to look for both a
  * field named "x", a getter named "x", and a setter named "x=".
  */
 abstract class AbstractFieldElement extends Element {
-  FunctionElement get getter;
-  FunctionElement get setter;
+  GetterElement get getter;
+  SetterElement get setter;
 }
 
 abstract class FunctionSignature {
   FunctionType get type;
   List<FormalElement> get requiredParameters;
   List<FormalElement> get optionalParameters;
 
   int get requiredParameterCount;
   int get optionalParameterCount;
   bool get optionalParametersAreNamed;
@@ skipping 180 matching lines @@
 
 /// JavaScript backend specific element for the body of constructor.
 // TODO(johnniwinther): Remove this class from the element model.
 abstract class ConstructorBodyElement extends MethodElement {
   FunctionElement get constructor;
 }
 
 /// [TypeDeclarationElement] defines the common interface for class/interface
 /// declarations and typedefs.
 abstract class TypeDeclarationElement extends Element implements AstElement {
+  /// Do not use [computeType] outside of the resolver; instead retrieve the
+  /// type from the [thisType] or [rawType], depending on the use case.
+  ///
+  /// Trying to access a type that has not been computed in resolution is an
+  /// error and calling [computeType] covers that error.
+  /// This method will go away!
+  @deprecated
+  GenericType computeType(Compiler compiler);
+
   /**
    * The `this type` for this type declaration.
    *
    * The type of [:this:] is the generic type based on this element in which
    * the type arguments are the declared type variables. For instance,
    * [:List<E>:] for [:List:] and [:Map<K,V>:] for [:Map:].
    *
    * For a class declaration this is the type of [:this:].
    */
   GenericType get thisType;
@@ skipping 212 matching lines @@
   Token get endToken;
 
   bool get hasNode;
   Node get node;
 
   MetadataAnnotation ensureResolved(Compiler compiler);
 }
 
 /// An [Element] that has a type.
 abstract class TypedElement extends Element {
+  /// Do not use [computeType] outside of the resolver; instead retrieve the
+  /// type from  [type] property.
+  ///
+  /// Trying to access a type that has not been computed in resolution is an
+  /// error and calling [computeType] covers that error.
+  /// This method will go away!
+  @deprecated
+  DartType computeType(Compiler compiler);
+
   DartType get type;
 }
 
 /// An [Element] that can define a function type.
 abstract class FunctionTypedElement extends Element {
   /// The function signature for the function type defined by this element,
   /// if any.
   FunctionSignature get functionSignature;
 }
 
@@ skipping 107 matching lines @@
   bool get isDeclaredByField;
 
   /// Returns `true` if this member is abstract.
   bool get isAbstract;
 
   /// If abstract, [implementation] points to the overridden concrete member,
   /// if any. Otherwise [implementation] points to the member itself.
   Member get implementation;
 }