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

lib/compiler/implementation/ssa/builder.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 Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 340 matching lines @@
       // Inside closure redirect references to itself to [:this:].
       HInstruction thisInstruction = new HThis();
       builder.add(thisInstruction);
       updateLocal(closureData.closureElement, thisInstruction);
     } else if (function.isInstanceMember()
                || function.isGenerativeConstructor()) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       ClassElement cls = function.getEnclosingClass();
-      Type type = cls.computeType(builder.compiler);
+      DartType type = cls.computeType(builder.compiler);
       HInstruction thisInstruction = new HThis(new HBoundedType.nonNull(type));
       builder.add(thisInstruction);
       directLocals[closureData.thisElement] = thisInstruction;
     }
   }
 
   bool hasValueForDirectLocal(Element element) {
     assert(element !== null);
     assert(isAccessedDirectly(element));
     return directLocals[element] !== null;
@@ skipping 72 matching lines @@
 
   HType cachedTypeOfThis;
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisElement);
     if (res.guaranteedType === null) {
       if (cachedTypeOfThis === null) {
         assert(closureData.isClosure());
         Element element = closureData.thisElement;
         ClassElement cls = element.enclosingElement.getEnclosingClass();
-        Type type = cls.computeType(builder.compiler);
+        DartType type = cls.computeType(builder.compiler);
         cachedTypeOfThis = new HBoundedType.nonNull(type);
       }
       res.guaranteedType = cachedTypeOfThis;
     }
     return res;
   }
 
   HLocalValue getLocal(Element element) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
@@ skipping 799 matching lines @@
   HInstruction potentiallyCheckType(HInstruction original,
                                     Element sourceElement) {
     if (!compiler.enableTypeAssertions) return original;
     return convertType(original, sourceElement,
                        HTypeConversion.CHECKED_MODE_CHECK);
   }
 
   HInstruction convertType(HInstruction original,
                            Element sourceElement,
                            int kind) {
-    Type type = sourceElement.computeType(compiler);
+    DartType type = sourceElement.computeType(compiler);
     if (type === null) return original;
     if (type.element === compiler.dynamicClass) return original;
     if (type.element === compiler.objectClass) return original;
 
     // If the original can't be null, type conversion also can't produce null.
     bool canBeNull = original.guaranteedType.canBeNull();
     HType convertedType =
         new HType.fromBoundedType(type, compiler, canBeNull);
 
     // No need to convert if we know the instruction has
@@ skipping 779 matching lines @@
       Node argument = node.arguments.head;
       TypeAnnotation typeAnnotation = argument.asTypeAnnotation();
       bool isNot = false;
       // TODO(ngeoffray): Duplicating pattern in resolver. We should
       // add a new kind of node.
       if (typeAnnotation == null) {
         typeAnnotation = argument.asSend().receiver;
         isNot = true;
       }
 
-      Type type = elements.getType(typeAnnotation);
+      DartType type = elements.getType(typeAnnotation);
       HInstruction typeInfo = null;
       if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
         pushInvokeHelper1(interceptors.getGetRuntimeTypeInfo(), expression);
         typeInfo = pop();
       }
       if (type.element.kind === ElementKind.TYPE_VARIABLE) {
         // TODO(karlklose): We emulate the behavior of the old frog
         // compiler and answer true to any is check involving a type variable
         // -- both is T and is !T -- until we have a proper implementation of
         // reified generics.
         stack.add(graph.addConstantBool(true));
       } else {
         HInstruction instruction;
         if (typeInfo !== null) {
           instruction = new HIs.withTypeInfoCall(type, expression, typeInfo);
         } else {
           instruction = new HIs(type, expression);
         }
         if (isNot) {
           add(instruction);
           instruction = new HNot(instruction);
         }
         push(instruction);
       }
     } else if (const SourceString("as") == op.source) {
       visit(node.receiver);
       HInstruction expression = pop();
       Node argument = node.arguments.head;
       TypeAnnotation typeAnnotation = argument.asTypeAnnotation();
-      Type type = elements.getType(typeAnnotation);
+      DartType type = elements.getType(typeAnnotation);
       HInstruction converted = convertType(expression, type.element,
                                            HTypeConversion.CAST_TYPE_CHECK);
       stack.add(converted);
     } else {
       visit(node.receiver);
       visit(node.argumentsNode);
       var right = pop();
       var left = pop();
       visitBinary(left, op, right);
     }
@@ skipping 334 matching lines @@
       push(new HInvokeSuper(inputs));
     } else {
       target = new HInvokeSuper(inputs);
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
   }
 
-  HInstruction analyzeTypeArgument(Type argument, Node currentNode) {
+  HInstruction analyzeTypeArgument(DartType argument, Node currentNode) {
     if (argument.element.isTypeVariable()) {
       if (work.element.isFactoryConstructor()
           || work.element.isGenerativeConstructor()) {
         // The type variable is stored in a parameter of the
         // factory.
         return localsHandler.readLocal(argument.element);
       } else if (work.element.isInstanceMember()) {
         // The type variable is stored in [this].
         pushInvokeHelper1(interceptors.getGetRuntimeTypeInfo(),
                           localsHandler.readThis());
@@ skipping 47 matching lines @@
     inputs.add(target);
     bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                   constructor, inputs);
     if (!succeeded) {
       // TODO(ngeoffray): Match the VM behavior and throw an
       // exception at runtime.
       compiler.cancel('Unimplemented non-matching static call', node: node);
     }
 
     TypeAnnotation annotation = getTypeAnnotationFromSend(node);
-    elements.getType(annotation).arguments.forEach((Type argument) {
+    elements.getType(annotation).arguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument, node));
     });
 
     HType elementType = computeType(constructor);
     HInstruction newInstance = new HInvokeStatic(inputs, elementType);
     pushWithPosition(newInstance, node);
   }
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
@@ skipping 902 matching lines @@
       HInstruction oldRethrowableException = rethrowableException;
       rethrowableException = exception;
 
       pushInvokeHelper1(interceptors.getExceptionUnwrapper(), exception);
       HInvokeStatic unwrappedException = pop();
       tryInstruction.exception = exception;
       Link<Node> link = node.catchBlocks.nodes;
 
       void pushCondition(CatchBlock catchBlock) {
         if (catchBlock.onKeyword != null) {
-          Type type = elements.getType(catchBlock.type);
+          DartType type = elements.getType(catchBlock.type);
           if (type == null) {
             compiler.cancel('On with unresolved type',
                             node: catchBlock.type);
           }
           HInstruction condition = new HIs(type, unwrappedException);
           push(condition);
         }
         else {
           VariableDefinitions declaration = catchBlock.formals.nodes.head;
           HInstruction condition = null;
           if (declaration.type == null) {
             condition = graph.addConstantBool(true);
             stack.add(condition);
           } else {
             // TODO(aprelev@gmail.com): Once old catch syntax is removed
             // "if" condition above and this "else" branch should be deleted as
             // type of declared variable won't matter for the catch
             // condition
-            Type type = elements.getType(declaration.type);
+            DartType type = elements.getType(declaration.type);
             if (type == null) {
               compiler.cancel('Catch with unresolved type', node: catchBlock);
             }
             condition = new HIs(type, unwrappedException, nullOk: true);
             push(condition);
           }
         }
       }
 
       void visitThen() {
@@ skipping 459 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }