Prefix resolution_types with Resolution.

pkg/compiler/lib/src/inferrer/inferrer_visitor.dart

 // Copyright (c) 2013, 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 inferrer_visitor;
 
 import 'dart:collection' show IterableMixin;
 
 import '../common.dart';
 import '../options.dart' show CompilerOptions;
@@ skipping 61 matching lines @@
    * Returns the least upper bound between [firstType] and
    * [secondType].
    */
   T computeLUB(T firstType, T secondType);
 
   /**
    * Returns the intersection between [T] and [annotation].
    * [isNullable] indicates whether the annotation implies a null
    * type.
    */
-  T narrowType(T type, DartType annotation, {bool isNullable: true});
+  T narrowType(T type, ResolutionDartType annotation, {bool isNullable: true});
 
   /**
    * Returns the non-nullable type [T].
    */
   T narrowNotNull(T type);
 
   /**
    * Returns a new type that unions [firstInput] and [secondInput].
    */
   T allocateDiamondPhi(T firstInput, T secondInput);
@@ skipping 909 matching lines @@
     isChecks.add(node);
   }
 
   void potentiallyAddNullCheck(Send node, Node receiver) {
     if (!accumulateIsChecks) return;
     if (!Elements.isLocal(elements[receiver])) return;
     isChecks.add(node);
   }
 
   void updateIsChecks(List<Node> tests, {bool usePositive}) {
-    void narrow(Element element, DartType type, Node node) {
+    void narrow(Element element, ResolutionDartType type, Node node) {
       if (element is LocalElement) {
         T existing = locals.use(element);
         T newType = types.narrowType(existing, type, isNullable: false);
         locals.update(element, newType, node);
       }
     }
 
     if (tests == null) return;
     for (Send node in tests) {
       if (node.isTypeTest) {
         if (node.isIsNotCheck) {
           if (usePositive) continue;
         } else {
           if (!usePositive) continue;
         }
-        DartType type = elements.getType(node.typeAnnotationFromIsCheckOrCast);
+        ResolutionDartType type =
+            elements.getType(node.typeAnnotationFromIsCheckOrCast);
         narrow(elements[node.receiver], type, node);
       } else {
         Element receiverElement = elements[node.receiver];
         Element argumentElement = elements[node.arguments.first];
         String operator = node.selector.asOperator().source;
         if ((operator == '==' && usePositive) ||
             (operator == '!=' && !usePositive)) {
           // Type the elements as null.
           if (Elements.isLocal(receiverElement)) {
             locals.update(receiverElement, types.nullType, node);
           }
           if (Elements.isLocal(argumentElement)) {
             locals.update(argumentElement, types.nullType, node);
           }
         } else {
           // Narrow the elements to a non-null type.
-          DartType objectType = closedWorld.commonElements.objectType;
+          ResolutionDartType objectType = closedWorld.commonElements.objectType;
           if (Elements.isLocal(receiverElement)) {
             narrow(receiverElement, objectType, node);
           }
           if (Elements.isLocal(argumentElement)) {
             narrow(argumentElement, objectType, node);
           }
         }
       }
     }
   }
@@ skipping 85 matching lines @@
   @override
   T visitNot(Send node, Node expression, _) {
     bool oldAccumulateIsChecks = accumulateIsChecks;
     accumulateIsChecks = false;
     visit(expression);
     accumulateIsChecks = oldAccumulateIsChecks;
     return types.boolType;
   }
 
   @override
-  T visitIs(Send node, Node expression, DartType type, _) {
+  T visitIs(Send node, Node expression, ResolutionDartType type, _) {
     potentiallyAddIsCheck(node);
     visit(expression);
     return types.boolType;
   }
 
   @override
-  T visitIsNot(Send node, Node expression, DartType type, _) {
+  T visitIsNot(Send node, Node expression, ResolutionDartType type, _) {
     potentiallyAddIsCheck(node);
     visit(expression);
     return types.boolType;
   }
 
   @override
-  T visitAs(Send node, Node expression, DartType type, _) {
+  T visitAs(Send node, Node expression, ResolutionDartType type, _) {
     T receiverType = visit(expression);
     return types.narrowType(receiverType, type);
   }
 
   @override
   T visitUnary(Send node, UnaryOperator operator, Node expression, _) {
     return handleDynamicInvoke(node);
   }
 
   @override
@@ skipping 177 matching lines @@
 
   T visitThrow(Throw node) {
     node.visitChildren(this);
     locals.seenReturnOrThrow = true;
     return types.nonNullEmpty();
   }
 
   T visitCatchBlock(CatchBlock node) {
     Node exception = node.exception;
     if (exception != null) {
-      DartType type = elements.getType(node.type);
+      ResolutionDartType type = elements.getType(node.type);
       T mask = type == null || type.treatAsDynamic || type.isTypeVariable
           ? types.dynamicType
           : types.nonNullSubtype(type.element);
       locals.update(elements[exception], mask, node);
     }
     Node trace = node.trace;
     if (trace != null) {
       locals.update(elements[trace], types.dynamicType, node);
     }
     visit(node.block);
@@ skipping 121 matching lines @@
     return type;
   }
 
   T visitCascade(Cascade node) {
     // Ignore the result of the cascade send and return the type of the cascade
     // receiver.
     visit(node.expression);
     return cascadeReceiverStack.removeLast();
   }
 }