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

lib/compiler/implementation/js_backend/emitter.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.
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
 class ClosureInvocationElement extends FunctionElement {
   ClosureInvocationElement(SourceString name,
@@ skipping 565 matching lines @@
                          void generateTypeTest(ClassElement element)) {
     if (compiler.codegenWorld.isChecks.contains(cls)) {
       generateTypeTest(cls);
     }
     generateInterfacesIsTests(cls, generateTypeTest, new Set<Element>());
   }
 
   void generateInterfacesIsTests(ClassElement cls,
                                  void generateTypeTest(ClassElement element),
                                  Set<Element> alreadyGenerated) {
-    for (Type interfaceType in cls.interfaces) {
+    for (DartType interfaceType in cls.interfaces) {
       Element element = interfaceType.element;
       if (!alreadyGenerated.contains(element) &&
           compiler.codegenWorld.isChecks.contains(element)) {
         alreadyGenerated.add(element);
         generateTypeTest(element);
       }
       generateInterfacesIsTests(element, generateTypeTest, alreadyGenerated);
     }
   }
 
@@ skipping 290 matching lines @@
         namer.instanceMethodName(null, Compiler.NO_SUCH_METHOD, 2);
 
     // Keep track of the JavaScript names we've already added so we
     // do not introduce duplicates (bad for code size).
     Set<String> addedJsNames = new Set<String>();
 
     // Keep track of the noSuchMethod holders for each possible
     // receiver type.
     Map<ClassElement, Set<ClassElement>> noSuchMethodHolders =
         new Map<ClassElement, Set<ClassElement>>();
-    Set<ClassElement> noSuchMethodHoldersFor(Type type) {
+    Set<ClassElement> noSuchMethodHoldersFor(DartType type) {
       ClassElement element = type.element;
       Set<ClassElement> result = noSuchMethodHolders[element];
       if (result === null) {
         // For now, we check the entire world to see if an object of
         // the given type may have a user-defined noSuchMethod
         // implementation. We could do better by only looking at
         // instantiated (or otherwise needed) classes.
         result = compiler.world.findNoSuchMethodHolders(type);
         noSuchMethodHolders[element] = result;
       }
       return result;
     }
 
     CodeBuffer generateMethod(String methodName, Selector selector) {
       CodeBuffer args = new CodeBuffer();
       for (int i = 0; i < selector.argumentCount; i++) {
         if (i != 0) args.add(', ');
         args.add('\$$i');
       }
       CodeBuffer buffer = new CodeBuffer();
       buffer.add('function($args) {\n');
       buffer.add('  return this.$noSuchMethodName("$methodName", [$args]);\n');
       buffer.add(' }');
       return buffer;
     }
 
     void addNoSuchMethodHandlers(SourceString ignore, Set<Selector> selectors) {
       // Cache the object class and type.
       ClassElement objectClass = compiler.objectClass;
-      Type objectType = objectClass.computeType(compiler);
+      DartType objectType = objectClass.computeType(compiler);
 
       for (Selector selector in selectors) {
         // Introduce a helper function that determines if the given
         // class has a member that matches the current name and
         // selector (grabbed from the scope).
         bool hasMatchingMember(ClassElement holder) {
           Element element = holder.lookupMember(selector.name);
           if (element === null) return false;
 
           // TODO(kasperl): Consider folding this logic into the
           // Selector.applies() method.
           if (element is AbstractFieldElement) {
             AbstractFieldElement field = element;
             if (selector.kind === SelectorKind.GETTER) {
               return field.getter !== null;
             } else if (selector.kind === SelectorKind.SETTER) {
               return field.setter !== null;
             } else {
               return false;
             }
           }
           return selector.applies(element, compiler);
         }
 
         // If the selector is typed, we check to see if that type may
         // have a user-defined noSuchMethod implementation. If not, we
         // skip the selector altogether.
-        Type receiverType = objectType;
+        DartType receiverType = objectType;
         ClassElement receiverClass = objectClass;
         if (selector is TypedSelector) {
           TypedSelector typedSelector = selector;
           receiverType = typedSelector.receiverType;
           receiverClass = receiverType.element;
         }
 
         // If the receiver class is guaranteed to have a member that
         // matches what we're looking for, there's no need to
         // introduce a noSuchMethod handler. It will never be called.
@@ skipping 201 matching lines @@
         sourceName = token.slowToString();
       }
       int totalOffset = bufferOffset + offset;
       sourceMapBuilder.addMapping(
           sourceFile, token.charOffset, sourceName, totalOffset);
     });
   }
 }
 
 typedef void DefineMemberFunction(String invocationName, CodeBuffer definition);