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

lib/compiler/implementation/compile_time_constants.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.
 
 class Constant implements Hashable {
   const Constant();
 
   bool isNull() => false;
   bool isBool() => false;
   bool isTrue() => false;
@@ skipping 271 matching lines @@
     StringConstant otherString = other;
     return (_hashCode == otherString._hashCode) && (value == otherString.value);
   }
 
   int hashCode() => _hashCode;
   DartString toDartString() => value;
   int get length => value.length;
 }
 
 class ObjectConstant extends Constant {
-  final Type type;
+  final DartType type;
 
   ObjectConstant(this.type);
   bool isObject() => true;
 
   // TODO(1603): The class should be marked as abstract, but the VM doesn't
   // currently allow this.
   abstract int hashCode();
 
   void _writeCanonicalizedJsCode(CodeBuffer buffer, ConstantHandler handler) {
     String name = handler.getNameForConstant(this);
     buffer.add(handler.compiler.namer.isolatePropertiesAccessForConstant(name));
   }
 }
 
 class ListConstant extends ObjectConstant {
   final List<Constant> entries;
   int _hashCode;
 
-  ListConstant(Type type, this.entries) : super(type) {
+  ListConstant(DartType type, this.entries) : super(type) {
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant input in entries) hash ^= input.hashCode();
     _hashCode = hash;
   }
   bool isList() => true;
 
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
     // TODO(floitsch): we should not need to go through the compiler to make
     // the list constant.
@@ skipping 40 matching lines @@
   static const SourceString LENGTH_NAME = const SourceString("length");
   static const SourceString JS_OBJECT_NAME = const SourceString("_jsObject");
   static const SourceString KEYS_NAME = const SourceString("_keys");
   static const SourceString PROTO_VALUE = const SourceString("_protoValue");
 
   final ListConstant keys;
   final List<Constant> values;
   final Constant protoValue;
   int _hashCode;
 
-  MapConstant(Type type, this.keys, this.values, this.protoValue)
+  MapConstant(DartType type, this.keys, this.values, this.protoValue)
       : super(type) {
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant value in values) hash ^= value.hashCode();
     _hashCode = hash;
   }
   bool isMap() => true;
 
   void _writeJsCode(CodeBuffer buffer, ConstantHandler handler) {
 
@@ skipping 75 matching lines @@
     return result;
   }
 
   int get length => keys.length;
 }
 
 class ConstructedConstant extends ObjectConstant {
   final List<Constant> fields;
   int _hashCode;
 
-  ConstructedConstant(Type type, this.fields) : super(type) {
+  ConstructedConstant(DartType type, this.fields) : super(type) {
     assert(type !== null);
     // TODO(floitsch): create a better hash.
     int hash = 0;
     for (Constant field in fields) {
       hash ^= field.hashCode();
     }
     hash ^= type.element.hashCode();
     _hashCode = hash;
   }
   bool isConstructedObject() => true;
@@ skipping 295 matching lines @@
 
   Constant visitLiteralList(LiteralList node) {
     if (!node.isConst()) error(node);
     List<Constant> arguments = <Constant>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty();
          link = link.tail) {
       arguments.add(evaluate(link.head));
     }
     // TODO(floitsch): get type from somewhere.
-    Type type = null;
+    DartType type = null;
     Constant constant = new ListConstant(type, arguments);
     compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitLiteralMap(LiteralMap node) {
     if (!node.isConst()) error(node);
     List<StringConstant> keys = <StringConstant>[];
     Map<StringConstant, Constant> map = new Map<StringConstant, Constant>();
     for (Link<Node> link = node.entries.nodes;
@@ skipping 13 matching lines @@
     Constant protoValue = null;
     for (StringConstant key in keys) {
       if (key.value == const LiteralDartString(MapConstant.PROTO_PROPERTY)) {
         protoValue = map[key];
       } else {
         values.add(map[key]);
       }
     }
     bool hasProtoKey = (protoValue !== null);
     // TODO(floitsch): this should be a List<String> type.
-    Type keysType = null;
+    DartType keysType = null;
     ListConstant keysList = new ListConstant(keysType, keys);
     compiler.constantHandler.registerCompileTimeConstant(keysList);
     SourceString className = hasProtoKey
                              ? MapConstant.DART_PROTO_CLASS
                              : MapConstant.DART_CLASS;
     ClassElement classElement = compiler.jsHelperLibrary.find(className);
     classElement.ensureResolved(compiler);
     // TODO(floitsch): copy over the generic type.
-    Type type = new InterfaceType(classElement);
+    DartType type = new InterfaceType(classElement);
     compiler.registerInstantiatedClass(classElement);
     Constant constant = new MapConstant(type, keysList, values, protoValue);
     compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitLiteralNull(LiteralNull node) {
     return new NullConstant();
   }
 
@@ skipping 200 matching lines @@
     Selector selector = elements.getSelector(send);
     List<Constant> arguments =
         evaluateArgumentsToConstructor(selector, send.arguments, constructor);
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(constructor, compiler);
     evaluator.evaluateConstructorFieldValues(arguments);
     List<Constant> jsNewArguments = evaluator.buildJsNewArguments(classElement);
 
     compiler.registerInstantiatedClass(classElement);
     // TODO(floitsch): take generic types into account.
-    Type type = classElement.computeType(compiler);
+    DartType type = classElement.computeType(compiler);
     Constant constant = new ConstructedConstant(type, jsNewArguments);
     compiler.constantHandler.registerCompileTimeConstant(constant);
     return constant;
   }
 
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   error(Node node) {
@@ skipping 151 matching lines @@
       Constant fieldValue = fieldValues[field];
       if (fieldValue === null) {
         // Use the default value.
         fieldValue = compiler.compileVariable(field);
       }
       jsNewArguments.add(fieldValue);
     });
     return jsNewArguments;
   }
 }