Rename Type to DartType to avoid conflicts with the class Type in the core library.

lib/compiler/implementation/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('dart:uri');
 
 #import('../tree/tree.dart');
 #import('../scanner/scannerlib.dart');
@@ skipping 104 matching lines @@
   Element(this.name, this.kind, this.enclosingElement) {
     assert(getLibrary() !== null);
   }
 
   Modifiers get modifiers => null;
 
   Node parseNode(DiagnosticListener listener) {
     listener.cancel("Internal Error: $this.parseNode", token: position());
   }
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     compiler.internalError("$this.computeType.", token: position());
   }
 
   void addMetadata(MetadataAnnotation annotation) {
     assert(annotation.annotatedElement === null);
     annotation.annotatedElement = this;
     metadata = metadata.prepend(annotation);
   }
 
   bool isFunction() => kind === ElementKind.FUNCTION;
@@ skipping 416 matching lines @@
 class PrefixElement extends Element {
   Map<SourceString, Element> imported;
   Token firstPosition;
 
   PrefixElement(SourceString prefix, Element enclosing, this.firstPosition)
       : imported = new Map<SourceString, Element>(),
         super(prefix, ElementKind.PREFIX, enclosing);
 
   lookupLocalMember(SourceString memberName) => imported[memberName];
 
-  Type computeType(Compiler compiler) => compiler.types.dynamicType;
+  DartType computeType(Compiler compiler) => compiler.types.dynamicType;
 
   Token position() => firstPosition;
 
   PrefixElement cloneTo(Element enclosing, DiagnosticListener listener) {
     return new PrefixElement(name, enclosing, firstPosition);
   }
 }
 
 class TypedefElement extends Element implements TypeDeclarationElement {
   Typedef cachedNode;
   TypedefType cachedType;
-  Type alias;
+  DartType alias;
 
   bool isResolved = false;
   bool isBeingResolved = false;
 
   TypedefElement(SourceString name, Element enclosing)
       : super(name, ElementKind.TYPEDEF, enclosing);
 
   /**
    * Function signature for a typedef of a function type. The signature is
    * kept to provide full information about parameter names through the mirror
    * system.
    *
    * The [functionSignature] is not available until the typedef element has been
    * resolved.
    */
   FunctionSignature functionSignature;
 
   TypedefType computeType(Compiler compiler) {
     if (cachedType !== null) return cachedType;
     Typedef node = parseNode(compiler);
-    Link<Type> parameters =
+    Link<DartType> parameters =
         TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
     cachedType = new TypedefType(this, parameters);
     compiler.resolveTypedef(this);
     return cachedType;
   }
 
-  Link<Type> get typeVariables => cachedType.typeArguments;
+  Link<DartType> get typeVariables => cachedType.typeArguments;
 
   Scope buildScope() =>
       new TypeDeclarationScope(enclosingElement.buildScope(), this);
 
   TypedefElement cloneTo(Element enclosing, DiagnosticListener listener) {
     TypedefElement result = new TypedefElement(name, enclosing);
     return result;
   }
 }
 
@@ skipping 21 matching lines @@
         identifier = initializedIdentifier.asSendSet().selector.asIdentifier();
       }
       if (name === identifier.source) {
         cachedNode = initializedIdentifier;
         return cachedNode;
       }
     }
     listener.cancel('internal error: could not find $name', node: variables);
   }
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return variables.computeType(compiler);
   }
 
-  Type get type => variables.type;
+  DartType get type => variables.type;
 
   bool isInstanceMember() {
     return isMember() && !modifiers.isStatic();
   }
 
   // Note: cachedNode.getBeginToken() will not be correct in all
   // cases, for example, for function typed parameters.
   Token position() => findMyName(variables.position());
 
   VariableElement cloneTo(Element enclosing, DiagnosticListener listener) {
@@ skipping 28 matching lines @@
     return result;
   }
 }
 
 // This element represents a list of variable or field declaration.
 // It contains the node, and the type. A [VariableElement] always
 // references its [VariableListElement]. It forwards its
 // [computeType] and [parseNode] methods to this element.
 class VariableListElement extends Element {
   VariableDefinitions cachedNode;
-  Type type;
+  DartType type;
   final Modifiers modifiers;
 
   /**
    * Function signature for a variable with a function type. The signature is
    * kept to provide full information about parameter names through the mirror
    * system.
    */
   FunctionSignature functionSignature;
 
   VariableListElement(ElementKind kind,
                       Modifiers this.modifiers,
                       Element enclosing)
     : super(null, kind, enclosing);
 
   VariableListElement.node(VariableDefinitions node,
                            ElementKind kind,
                            Element enclosing)
     : super(null, kind, enclosing),
       this.cachedNode = node,
       this.modifiers = node.modifiers;
 
   VariableDefinitions parseNode(DiagnosticListener listener) {
     return cachedNode;
   }
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     if (type != null) return type;
     VariableDefinitions node = parseNode(compiler);
     if (node.type !== null) {
       type = compiler.resolveTypeAnnotation(this, node.type);
     } else {
       // Is node.definitions exactly one FunctionExpression?
       Link<Node> link = node.definitions.nodes;
       if (!link.isEmpty() &&
           link.head.asFunctionExpression() !== null &&
           link.tail.isEmpty()) {
@@ skipping 23 matching lines @@
       result = new VariableListElement(kind, modifiers, enclosing);
     }
     return result;
   }
 }
 
 class ForeignElement extends Element {
   ForeignElement(SourceString name, ContainerElement enclosingElement)
     : super(name, ElementKind.FOREIGN, enclosingElement);
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     return compiler.types.dynamicType;
   }
 
   parseNode(DiagnosticListener listener) {
     throw "internal error: ForeignElement has no node";
   }
 
   ForeignElement cloneTo(Element enclosing, DiagnosticListener listener) {
     ForeignElement result = new ForeignElement(name, enclosing);
     return result;
   }
 }
 
 class AbstractFieldElement extends Element {
   FunctionElement getter;
   FunctionElement setter;
 
   AbstractFieldElement(SourceString name, Element enclosing)
       : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
 
-  Type computeType(Compiler compiler) {
+  DartType computeType(Compiler compiler) {
     throw "internal error: AbstractFieldElement has no type";
   }
 
   Node parseNode(DiagnosticListener listener) {
     throw "internal error: AbstractFieldElement has no node";
   }
 
   position() {
     // The getter and setter may be defined in two different
     // compilation units.  However, we know that one of them is
@@ skipping 29 matching lines @@
     listener.cancel("Cannot clone synthetic AbstractFieldElement",
                     element: this);
   }
 }
 
 // TODO(johnniwinther): [FunctionSignature] should be merged with
 // [FunctionType].
 class FunctionSignature {
   Link<Element> requiredParameters;
   Link<Element> optionalParameters;
-  Type returnType;
+  DartType returnType;
   int requiredParameterCount;
   int optionalParameterCount;
   FunctionSignature(this.requiredParameters,
                     this.optionalParameters,
                     this.requiredParameterCount,
                     this.optionalParameterCount,
                     this.returnType);
 
   void forEachParameter(void function(Element parameter)) {
     for (Link<Element> link = requiredParameters;
          !link.isEmpty();
          link = link.tail) {
       function(link.head);
     }
     for (Link<Element> link = optionalParameters;
          !link.isEmpty();
          link = link.tail) {
       function(link.head);
     }
   }
 
   int get parameterCount => requiredParameterCount + optionalParameterCount;
 }
 
 class FunctionElement extends Element {
   FunctionExpression cachedNode;
-  Type type;
+  DartType type;
   final Modifiers modifiers;
 
   FunctionSignature functionSignature;
 
   /**
    * A function declaration that should be parsed instead of the current one.
    * The patch should be parsed as if it was in the current scope. Its
    * signature must match this function's signature.
    */
   // TODO(lrn): Consider using [defaultImplementation] to store the patch.
@@ skipping 155 matching lines @@
 
   SynthesizedConstructorElement cloneTo(Element enclosing,
                                         DiagnosticListener listener) {
     return new SynthesizedConstructorElement(enclosing);
   }
 }
 
 class VoidElement extends Element {
   VoidElement(Element enclosing)
       : super(const SourceString('void'), ElementKind.VOID, enclosing);
-  Type computeType(compiler) => compiler.types.voidType;
+  DartType computeType(compiler) => compiler.types.voidType;
   Node parseNode(_) {
     throw 'internal error: parseNode on void';
   }
   bool impliesType() => true;
 }
 
 /**
  * [TypeDeclarationElement] defines the common interface for class/interface
  * declarations and typedefs.
  */
 abstract class TypeDeclarationElement implements Element {
   // TODO(johnniwinther): This class should eventually be a mixin.
 
   /**
    * The type variables declared on this declaration. The type variables are not
    * available until the type of the element has been computed through
    * [computeType].
    */
   // TODO(johnniwinther): Find a (better) way to decouple [typeVariables] from
   // [Compiler].
-  abstract Link<Type> get typeVariables;
+  abstract Link<DartType> get typeVariables;
 
   /**
    * Creates the type variables, their type and corresponding element, for the
    * type variables declared in [parameter] on [element]. The bounds of the type
    * variables are not set until [element] has been resolved.
    */
-  static Link<Type> createTypeVariables(TypeDeclarationElement element,
+  static Link<DartType> createTypeVariables(TypeDeclarationElement element,
                                         NodeList parameters) {
-    if (parameters === null) return const EmptyLink<Type>();
+    if (parameters === null) return const EmptyLink<DartType>();
 
     // Create types and elements for type variable.
-    var arguments = new LinkBuilder<Type>();
+    var arguments = new LinkBuilder<DartType>();
     for (Link link = parameters.nodes; !link.isEmpty(); link = link.tail) {
       TypeVariable node = link.head;
       SourceString variableName = node.name.source;
       TypeVariableElement variableElement =
           new TypeVariableElement(variableName, element, node);
       TypeVariableType variableType = new TypeVariableType(variableElement);
       variableElement.type = variableType;
       arguments.addLast(variableType);
     }
     return arguments.toLink();
   }
 }
 
 class ClassElement extends ScopeContainerElement
     implements TypeDeclarationElement {
   final int id;
   InterfaceType type;
-  Type supertype;
-  Type defaultClass;
-  Link<Type> interfaces;
+  DartType supertype;
+  DartType defaultClass;
+  Link<DartType> interfaces;
   SourceString nativeName;
   int supertypeLoadState;
   int resolutionState;
 
   // backendMembers are members that have been added by the backend to simplify
   // compilation. They don't have any user-side counter-part.
   Link<Element> backendMembers = const EmptyLink<Element>();
 
-  Link<Type> allSupertypes;
+  Link<DartType> allSupertypes;
 
   // Lazily applied patch of class members.
   ClassElement patch = null;
 
   ClassElement(SourceString name, Element enclosing, this.id, int initialState)
     : supertypeLoadState = initialState,
       resolutionState = initialState,
       super(name, ElementKind.CLASS, enclosing);
 
   InterfaceType computeType(compiler) {
     if (type == null) {
       ClassNode node = parseNode(compiler);
-      Link<Type> parameters =
+      Link<DartType> parameters =
           TypeDeclarationElement.createTypeVariables(this, node.typeParameters);
       type = new InterfaceType(this, parameters);
     }
     return type;
   }
 
   bool get isPatched => patch != null;
 
-  Link<Type> get typeVariables => type.arguments;
+  Link<DartType> get typeVariables => type.arguments;
 
   ClassElement ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveClass(this);
     }
     return this;
   }
 
   /**
    * Lookup local members in the class. This will ignore constructors.
@@ skipping 201 matching lines @@
     void fieldFilter(ClassElement enclosingClass, Element member) {
       if (member.isInstanceMember() && member.kind == ElementKind.FIELD) {
         f(enclosingClass, member);
       }
     }
 
     forEachMember(fieldFilter, includeBackendMembers, includeSuperMembers);
   }
 
   bool implementsInterface(ClassElement intrface) {
-    for (Type implementedInterfaceType in allSupertypes) {
+    for (DartType implementedInterfaceType in allSupertypes) {
       ClassElement implementedInterface = implementedInterfaceType.element;
       if (implementedInterface === intrface) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Returns true if [this] is a subclass of [cls].
@@ skipping 13 matching lines @@
   bool isNative() => nativeName != null;
   int hashCode() => id;
 
   Scope buildScope() =>
       new ClassScope(enclosingElement.buildScope(), this);
 
   ClassElement cloneTo(Element enclosing, DiagnosticListener listener) {
     listener.internalErrorOnElement(this, 'unsupported operation');
   }
 
-  Link<Type> get allSupertypesAndSelf {
+  Link<DartType> get allSupertypesAndSelf {
     return allSupertypes.prepend(new InterfaceType(this));
   }
 }
 
 class Elements {
   static bool isLocal(Element element) {
     return !Element.isInvalid(element)
             && !element.isInstanceMember()
             && !isStaticOrTopLevelField(element)
             && !isStaticOrTopLevelFunction(element)
@@ skipping 190 matching lines @@
 
   bool get isSwitch => statement is SwitchStatement;
 
   Token position() => statement.getBeginToken();
   String toString() => statement.toString();
 }
 
 class TypeVariableElement extends Element {
   final Node cachedNode;
   TypeVariableType type;
-  Type bound;
+  DartType bound;
 
   TypeVariableElement(name, Element enclosing, this.cachedNode,
                       [this.type, this.bound])
     : super(name, ElementKind.TYPE_VARIABLE, enclosing);
 
   TypeVariableType computeType(compiler) => type;
 
   Node parseNode(compiler) => cachedNode;
 
   String toString() => "${enclosingElement.toString()}.${name.slowToString()}";
@@ skipping 46 matching lines @@
 
   MetadataAnnotation ensureResolved(Compiler compiler) {
     if (resolutionState == STATE_NOT_STARTED) {
       compiler.resolver.resolveMetadataAnnotation(this);
     }
     return this;
   }
 
   String toString() => 'MetadataAnnotation($value, $resolutionState)';
 }