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

lib/compiler/implementation/ssa/codegen.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 SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
@@ skipping 1461 matching lines @@
       }
     }
     push(jsPropertyCall(object, methodName, arguments), node);
   }
 
   Selector getOptimizedSelectorFor(HInvokeDynamic node,
                                    Selector defaultSelector) {
     // TODO(4434): For private members we need to use the untyped selector.
     if (defaultSelector.name.isPrivate()) return defaultSelector;
     HType receiverHType = types[node.inputs[0]];
-    Type receiverType = receiverHType.computeType(compiler);
+    DartType receiverType = receiverHType.computeType(compiler);
     if (receiverType !== null) {
       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     use(node.receiver);
     Selector setter = node.selector;
@@ skipping 79 matching lines @@
       push(jsPropertyCall(method, "call", visitArguments(node.inputs)), node);
     }
     world.registerStaticUse(superMethod);
   }
 
   visitFieldGet(HFieldGet node) {
     String name = compiler.namer.getName(node.element);
     use(node.receiver);
     push(new js.PropertyAccess.field(pop(), name), node);
     HType receiverHType = types[node.receiver];
-    Type type = receiverHType.computeType(compiler);
+    DartType type = receiverHType.computeType(compiler);
     if (type != null) {
       world.registerFieldGetter(
           node.element.name, node.element.getLibrary(), type);
     }
   }
 
   // Determine if an instruction is a simple number computation
   // involving only things with guaranteed number types and a given
   // field.
   bool isSimpleFieldNumberComputation(HInstruction value, HFieldSet node) {
     if (value.guaranteedType.union(HType.NUMBER) == HType.NUMBER) return true;
     if (value is HBinaryArithmetic) {
       return (isSimpleFieldNumberComputation(value.left, node) &&
               isSimpleFieldNumberComputation(value.right, node));
     }
     if (value is HFieldGet) return value.element == node.element;
     return false;
   }
 
   visitFieldSet(HFieldSet node) {
     if (work.element.isGenerativeConstructorBody() &&
         node.element.isMember() &&
         node.value.hasGuaranteedType() &&
         node.block.dominates(currentGraph.exit)) {
       backend.updateFieldConstructorSetters(node.element,
                                             node.value.guaranteedType);
     }
     String name = compiler.namer.getName(node.element);
-    Type type = types[node.receiver].computeType(compiler);
+    DartType type = types[node.receiver].computeType(compiler);
     if (type != null) {
       if (!work.element.isGenerativeConstructorBody()) {
         world.registerFieldSetter(
             node.element.name, node.element.getLibrary(), type);
       }
       // Determine the types seen so far for the field. If only number
       // types have been seen and the value of the field set is a
       // simple number computation only depending on that field, we
       // can safely keep the number type for the field.
       HType fieldSettersType = backend.fieldSettersTypeSoFar(node.element);
@@ skipping 601 matching lines @@
     js.Expression objectTest = pop();
     checkArray(input, '===');
     js.Expression arrayTest = pop();
     checkType(input, element);
     push(new js.Binary('&&',
                        objectTest,
                        new js.Binary('||', arrayTest, pop())));
   }
 
   void visitIs(HIs node) {
-    Type type = node.typeExpression;
+    DartType type = node.typeExpression;
     Element element = type.element;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("visitIs for type variables", instruction: node);
     } else if (element.kind === ElementKind.TYPEDEF) {
       compiler.unimplemented("visitIs for typedefs", instruction: node);
     }
     LibraryElement coreLibrary = compiler.coreLibrary;
     ClassElement objectClass = compiler.objectClass;
     HInstruction input = node.expression;
 
@@ skipping 33 matching lines @@
       js.Expression objectTest = pop();
       checkType(input, element);
       push(new js.Binary('&&', objectTest, pop()), node);
     } else {
       checkType(input, element);
       attachLocationToLast(node);
     }
     if (node.hasTypeInfo()) {
       InterfaceType interfaceType = type;
       ClassElement cls = type.element;
-      Link<Type> arguments = interfaceType.arguments;
+      Link<DartType> arguments = interfaceType.arguments;
       js.Expression result = pop();
       for (TypeVariableType typeVariable in cls.typeVariables) {
         use(node.typeInfoCall);
         // TODO(johnniwinther): Retrieve the type name properly and not through
         // [toString]. Note: Two cases below [typeVariable] and
         // [arguments.head].
         js.PropertyAccess field =
             new js.PropertyAccess.field(pop(), typeVariable.toString());
         js.Expression genericName = new js.LiteralString("'${arguments.head}'");
         js.Binary eqTest = new js.Binary('===', field, genericName);
@@ skipping 413 matching lines @@
   bool visitLoopInfo(HLoopBlockInformation info) {
     if (info.start.hasBailoutTargets()) return false;
     if (info.loopHeader.hasBailoutTargets()) return false;
     return super.visitLoopInfo(info);
   }
 
   bool visitTryInfo(HTryBlockInformation info) => false;
   bool visitSequenceInfo(HStatementSequenceInformation info) => false;
 
   void visitTypeGuard(HTypeGuard node) {
-    // Do nothing. Type guards are only used in the optimized version.
+    // Do nothing. DartType guards are only used in the optimized version.

[kasperl, 2012/08/30 14:11:27]

Undo this edit.

   }
 
   void visitBailoutTarget(HBailoutTarget node) {
     if (!propagator.hasComplexBailoutTargets) return;
 
     js.Block nextBlock = new js.Block.empty();
     js.Case clause = new js.Case(new js.LiteralNumber('${node.state}'),
                                  nextBlock);
     currentBailoutSwitch.cases.add(clause);
     currentContainer = nextBlock;
@@ skipping 193 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }