Prefix resolution_types with Resolution.

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.dart';
 import '../common/resolution.dart' show Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/constructors.dart';
@@ skipping 123 matching lines @@
  * A declared element of a program.
  *
  * The declared elements of a program include classes, methods,
  * fields, variables, parameters, etc.
  *
  * Sometimes it makes sense to construct "synthetic" elements that
  * have not been declared anywhere in a program, for example, there
  * are elements corresponding to "dynamic", "null", and unresolved
  * references.
  *
- * Elements are distinct from types ([DartType]). For example, there
+ * Elements are distinct from types ([ResolutionDartType]). For example, there
  * is one declaration of the class List, but several related types,
  * for example, List, List<int>, List<String>, etc.
  *
  * Elements are distinct from AST nodes ([Node]), and there normally is a
  * one-to-one correspondence between an AST node and an element
  * (except that not all kinds of AST nodes have an associated
  * element).
  *
  * AST nodes represent precisely what is written in source code, for
  * example, when a user writes "class MyClass {}", the corresponding
@@ skipping 836 matching lines @@
   GetterElement get loadLibrary;
 }
 
 /// A type alias definition.
 abstract class TypedefElement extends Element
     implements AstElement, TypeDeclarationElement, FunctionTypedElement {
   /// The type defined by this typedef with the type variables as its type
   /// arguments.
   ///
   /// For instance `F<T>` for `typedef void F<T>(T t)`.
-  TypedefType get thisType;
+  ResolutionTypedefType get thisType;
 
   /// The type defined by this typedef with `dynamic` as its type arguments.
   ///
   /// For instance `F<dynamic>` for `typedef void F<T>(T t)`.
-  TypedefType get rawType;
+  ResolutionTypedefType 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;
+  ResolutionDartType get alias;
 
   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
@@ skipping 135 matching lines @@
  * 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 {
   GetterElement get getter;
   SetterElement get setter;
 }
 
 abstract class FunctionSignature {
-  FunctionType get type;
-  DartType get returnType;
-  List<DartType> get typeVariables;
+  ResolutionFunctionType get type;
+  ResolutionDartType get returnType;
+  List<ResolutionDartType> get typeVariables;
   List<FormalElement> get requiredParameters;
   List<FormalElement> get optionalParameters;
 
   int get requiredParameterCount;
   int get optionalParameterCount;
   bool get optionalParametersAreNamed;
   bool get hasOptionalParameters;
 
   int get parameterCount;
   List<FormalElement> get orderedOptionalParameters;
@@ skipping 20 matching lines @@
 
   FunctionElement get patch;
   FunctionElement get origin;
 
   bool get hasFunctionSignature;
 
   /// The parameters of this function.
   List<ParameterElement> get parameters;
 
   /// The type of this function.
-  FunctionType get type;
+  ResolutionFunctionType get type;
 
   /// The synchronous/asynchronous marker on this function.
   AsyncMarker get asyncMarker;
 
   /// `true` if this function is external.
   bool get isExternal;
 }
 
 /// A getter or setter.
 abstract class AccessorElement extends MethodElement {
@@ skipping 124 matching lines @@
   ///       - it is part of a redirection cycle,
   ///       - the effective target is a generative constructor on an abstract
   ///         class, or
   ///       - this constructor is constant but the effective target is not,
   ///       - the arguments to this constructor are incompatible with the
   ///         parameters of the effective target.
   bool get isEffectiveTargetMalformed;
 
   /// Compute the type of the effective target of this constructor for an
   /// instantiation site with type [:newType:].
-  InterfaceType computeEffectiveTargetType(InterfaceType newType);
+  ResolutionInterfaceType computeEffectiveTargetType(
+      ResolutionInterfaceType newType);
 
   /// If this is a synthesized constructor [definingConstructor] points to
   /// the generative constructor from which this constructor was created.
   /// Otherwise [definingConstructor] is `null`.
   ///
   /// Consider for instance this hierarchy:
   ///
   ///     class C { C.c(a, {b});
   ///     class D {}
   ///     class E = C with D;
@@ skipping 35 matching lines @@
 
 /// [GenericElement] defines the common interface for generic functions and
 /// [TypeDeclarationElement].
 abstract class GenericElement extends Element implements AstElement {
   /// Do not use [computeType] outside of the resolver.
   ///
   /// 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(Resolution resolution);
+  ResolutionDartType computeType(Resolution resolution);
 
   /**
    * 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;
+  List<ResolutionDartType> get typeVariables;
 }
 
 /// [TypeDeclarationElement] defines the common interface for class/interface
 /// declarations and typedefs.
 abstract class TypeDeclarationElement extends GenericElement {
   /// 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.
@@ skipping 20 matching lines @@
    *
    * The raw type is the generic type base on this element in which the type
    * arguments are all [dynamic]. For instance [:List<dynamic>:] for [:List:]
    * and [:Map<dynamic,dynamic>:] for [:Map:]. For non-generic classes [rawType]
    * is the same as [thisType].
    *
    * The [rawType] field is a canonicalization of the raw type and should be
    * used to distinguish explicit and implicit uses of the [dynamic]
    * type arguments. For instance should [:List:] be the [rawType] of the
    * [:List:] class element whereas [:List<dynamic>:] should be its own
-   * instantiation of [InterfaceType] with [:dynamic:] as type argument. Using
-   * this distinction, we can print the raw type with type arguments only when
-   * the input source has used explicit type arguments.
+   * instantiation of [ResolutionInterfaceType] with [:dynamic:] as type
+   * argument. Using this distinction, we can print the raw type with type
+   * arguments only when the input source has used explicit type arguments.
    */
   GenericType get rawType;
 
   bool get isResolved;
 
   void ensureResolved(Resolution resolution);
 }
 
 abstract class ClassElement extends TypeDeclarationElement
     implements ScopeContainerElement, ClassEntity {
   /// The length of the longest inheritance path from [:Object:].
   int get hierarchyDepth;
 
-  InterfaceType get rawType;
-  InterfaceType get thisType;
+  ResolutionInterfaceType get rawType;
+  ResolutionInterfaceType get thisType;
   ClassElement get superclass;
 
   /// The direct supertype of this class.
-  DartType get supertype;
+  ResolutionDartType get supertype;
 
   /// Ordered set of all supertypes of this class including the class itself.
   OrderedTypeSet get allSupertypesAndSelf;
 
   /// A list of all supertypes of this class excluding the class itself.
-  Link<DartType> get allSupertypes;
+  Link<ResolutionDartType> get allSupertypes;
 
   /// Returns the this type of this class as an instance of [cls].
-  InterfaceType asInstanceOf(ClassElement cls);
+  ResolutionInterfaceType asInstanceOf(ClassElement cls);
 
   /// A list of all direct superinterfaces of this class.
-  Link<DartType> get interfaces;
+  Link<ResolutionDartType> get interfaces;
 
   bool get hasConstructor;
   Link<Element> get constructors;
 
   ClassElement get patch;
   ClassElement get origin;
   ClassElement get declaration;
   ClassElement get implementation;
 
   /// `true` if this class is an enum declaration.
@@ skipping 90 matching lines @@
   void forEachClassMember(f(Member member));
 
   /// Looks up the member [name] in the interface of this class.
   MemberSignature lookupInterfaceMember(Name name);
 
   /// Calls [f] with each member of the interface of this class.
   void forEachInterfaceMember(f(MemberSignature member));
 
   /// Returns the type of the 'call' method in the interface of this class, or
   /// `null` if the interface has no 'call' method.
-  FunctionType get callType;
+  ResolutionFunctionType get callType;
 }
 
 abstract class MixinApplicationElement extends ClassElement {
   ClassElement get mixin;
-  InterfaceType get mixinType;
+  ResolutionInterfaceType get mixinType;
 
   /// If this is an unnamed mixin application [subclass] is the subclass for
   /// which this mixin application is created.
   ClassElement get subclass;
 }
 
 /// Enum declaration.
 abstract class EnumClassElement extends ClassElement {
   /// The static fields implied by the enum values.
   List<EnumConstantElement> get enumValues;
@@ skipping 52 matching lines @@
   get enclosingElement;
 
   /// The class, typedef, function, method, or function typed parameter on
   /// which this type variable is defined.
   GenericElement get typeDeclaration;
 
   /// The index of this type variable within its type declaration.
   int get index;
 
   /// The [type] defined by the type variable.
-  TypeVariableType get type;
+  ResolutionTypeVariableType get type;
 
   /// The upper bound on the type variable. If not explicitly declared, this is
   /// `Object`.
-  DartType get bound;
+  ResolutionDartType get bound;
 }
 
 abstract class MetadataAnnotation implements Spannable {
   /// The front-end constant of this metadata annotation.
   ConstantExpression get constant;
   Element get annotatedElement;
   SourceSpan get sourcePosition;
 
   bool get hasNode;
   Node get node;
 
   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(Resolution resolution);
+  ResolutionDartType computeType(Resolution resolution);
 
-  DartType get type;
+  ResolutionDartType get type;
 }
 
 /// An [Element] that can define a function type.
 abstract class FunctionTypedElement extends Element implements GenericElement {
   /// The function signature for the function type defined by this element,
   /// if any.
   FunctionSignature get functionSignature;
 }
 
 /// An [Element] that holds a [TreeElements] mapping.
@@ skipping 130 matching lines @@
 ///
 /// A [MemberSignature] may be defined by a member declaration or may be
 /// synthetized from a set of declarations.
 abstract class MemberSignature {
   /// The name of this member.
   Name get name;
 
   /// The type of the member when accessed. For getters and setters this is the
   /// return type and argument type, respectively. For methods the type is the
   /// [functionType] defined by the return type and parameters.
-  DartType get type;
+  ResolutionDartType get type;
 
   /// The function type of the member. For a getter `Foo get foo` this is
   /// `() -> Foo`, for a setter `void set foo(Foo _)` this is `(Foo) -> void`.
   /// For methods the function type is defined by the return type and
   /// parameters.
-  FunctionType get functionType;
+  ResolutionFunctionType get functionType;
 
   /// Returns `true` if this member is a getter, possibly implictly defined by a
   /// field declaration.
   bool get isGetter;
 
   /// Returns `true` if this member is a setter, possibly implictly defined by a
   /// field declaration.
   bool get isSetter;
 
   /// Returns `true` if this member is a method, that is neither a getter nor
@@ skipping 21 matching lines @@
   /// a getter or setter defined by a field.
   Element get element;
 
   /// The instance of the class that declared this member.
   ///
   /// For instance:
   ///   class A<T> { T m() {} }
   ///   class B<S> extends A<S> {}
   /// The declarer of `m` in `A` is `A<T>` whereas the declarer of `m` in `B` is
   /// `A<S>`.
-  InterfaceType get declarer;
+  ResolutionInterfaceType get declarer;
 
   /// Returns `true` if this member is static.
   bool get isStatic;
 
   /// Returns `true` if this member is a getter or setter implicitly declared
   /// by a field.
   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;
 }