Add Resolution and Parsing interfaces for computeType, ensureResolved and parseNode.

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 '../common/resolution.dart' show
+    Resolution;
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../diagnostics/diagnostic_listener.dart';
 import '../diagnostics/messages.dart' show
 MessageKind;
 import '../diagnostics/source_span.dart' show
     SourceSpan;
@@ skipping 943 matching lines @@
   ///
   /// For instance `F<dynamic>` for `typedef void F<T>(T t)`.
   TypedefType get rawType;
 
   /// The type, function type if well-defined, for which this typedef is an
   /// alias.
   ///
   /// For instance `(int)->void` for `typedef void F(int)`.
   DartType get alias;
 
-  void checkCyclicReference(Compiler compiler);
+  void checkCyclicReference(Resolution resolution);
 }
 
 /// An executable element is an element that can hold code.
 ///
 /// These elements variables (fields, parameters and locals), which can hold
 /// code in their initializer, and functions (including methods and
 /// constructors), which can hold code in their body.
 abstract class ExecutableElement extends Element
     implements TypedElement, AstElement {
   /// The outermost member that contains this element.
@@ skipping 327 matching lines @@
   /// The name of this type declaration, taking privacy into account.
   Name get memberName;
 
   /// 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);
+  GenericType computeType(Resolution resolution);
 
   /**
    * 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:].
    */
@@ skipping 19 matching lines @@
 
   /**
    * The type variables declared on this declaration. The type variables are not
    * available until the type of the element has been computed through
    * [computeType].
    */
   List<DartType> get typeVariables;
 
   bool get isResolved;
 
-  void ensureResolved(Compiler compiler);
+  void ensureResolved(Resolution resolution);
 }
 
 abstract class ClassElement extends TypeDeclarationElement
     implements ScopeContainerElement {
   /// The length of the longest inheritance path from [:Object:].
   int get hierarchyDepth;
 
   InterfaceType get rawType;
   InterfaceType get thisType;
   ClassElement get superclass;
@@ skipping 194 matching lines @@
   /// The front-end constant of this metadata annotation.
   ConstantExpression get constant;
   Element get annotatedElement;
   int get resolutionState;
   Token get beginToken;
   Token get endToken;
 
   bool get hasNode;
   Node get node;
 
-  MetadataAnnotation ensureResolved(Compiler compiler);
+  MetadataAnnotation ensureResolved(Resolution resolution);
 }
 
 /// 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 computeType(Resolution resolution);
 
   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 110 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;
 }