Prefix resolution_types with Resolution.

pkg/compiler/lib/src/resolution/class_hierarchy.dart

 // Copyright (c) 2015, 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 dart2js.resolution.class_hierarchy;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution;
 import '../core_types.dart' show CommonElements;
 import '../elements/resolution_types.dart';
@@ skipping 10 matching lines @@
 import '../tree/tree.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/feature.dart' show Feature;
 import '../util/util.dart' show Link, Setlet;
 import 'enum_creator.dart';
 import 'members.dart' show lookupInScope;
 import 'registry.dart' show ResolutionRegistry;
 import 'resolution_common.dart' show CommonResolverVisitor, MappingVisitor;
 import 'scope.dart' show Scope, TypeDeclarationScope;
 
-class TypeDefinitionVisitor extends MappingVisitor<DartType> {
+class TypeDefinitionVisitor extends MappingVisitor<ResolutionDartType> {
   Scope scope;
   final TypeDeclarationElement enclosingElement;
   TypeDeclarationElement get element => enclosingElement;
 
   TypeDefinitionVisitor(Resolution resolution, TypeDeclarationElement element,
       ResolutionRegistry registry)
       : this.enclosingElement = element,
         scope = Scope.buildEnclosingScope(element),
         super(resolution, registry);
 
   CommonElements get commonElements => resolution.commonElements;
 
-  DartType get objectType => commonElements.objectType;
+  ResolutionDartType get objectType => commonElements.objectType;
 
   void resolveTypeVariableBounds(NodeList node) {
     if (node == null) return;
 
     Setlet<String> nameSet = new Setlet<String>();
     // Resolve the bounds of type variables.
-    Iterator<DartType> types = element.typeVariables.iterator;
+    Iterator<ResolutionDartType> types = element.typeVariables.iterator;
     Link<Node> nodeLink = node.nodes;
     while (!nodeLink.isEmpty) {
       types.moveNext();
-      TypeVariableType typeVariable = types.current;
+      ResolutionTypeVariableType typeVariable = types.current;
       String typeName = typeVariable.name;
       TypeVariable typeNode = nodeLink.head;
       registry.useType(typeNode, typeVariable);
       if (nameSet.contains(typeName)) {
         reporter.reportErrorMessage(
             typeNode,
             MessageKind.DUPLICATE_TYPE_VARIABLE_NAME,
             {'typeVariableName': typeName});
       }
       nameSet.add(typeName);
 
       TypeVariableElementX variableElement = typeVariable.element;
       if (typeNode.bound != null) {
-        DartType boundType =
+        ResolutionDartType boundType =
             typeResolver.resolveTypeAnnotation(this, typeNode.bound);
         variableElement.boundCache = boundType;
 
         void checkTypeVariableBound() {
           Link<TypeVariableElement> seenTypeVariables =
               const Link<TypeVariableElement>();
           seenTypeVariables = seenTypeVariables.prepend(variableElement);
-          DartType bound = boundType;
+          ResolutionDartType bound = boundType;
           while (bound.isTypeVariable) {
             TypeVariableElement element = bound.element;
             if (seenTypeVariables.contains(element)) {
               if (identical(element, variableElement)) {
                 // Only report an error on the checked type variable to avoid
                 // generating multiple errors for the same cyclicity.
                 reporter.reportWarningMessage(
                     typeNode.name,
                     MessageKind.CYCLIC_TYPE_VARIABLE,
                     {'typeVariableName': variableElement.name});
@@ skipping 27 matching lines @@
  * or indirectly (through [ClassElement.ensureResolved]) for any other
  * types.
  */
 class ClassResolverVisitor extends TypeDefinitionVisitor {
   BaseClassElementX get element => enclosingElement;
 
   ClassResolverVisitor(Resolution resolution, ClassElement classElement,
       ResolutionRegistry registry)
       : super(resolution, classElement, registry);
 
-  DartType visitClassNode(ClassNode node) {
+  ResolutionDartType visitClassNode(ClassNode node) {
     if (element == null) {
       throw reporter.internalError(node, 'element is null');
     }
     if (element.resolutionState != STATE_STARTED) {
       throw reporter.internalError(
           element, 'cyclic resolution of class $element');
     }
 
     element.computeType(resolution);
     scope = new TypeDeclarationScope(scope, element);
     // TODO(ahe): It is not safe to call resolveTypeVariableBounds yet.
     // As a side-effect, this may get us back here trying to
     // resolve this class again.
     resolveTypeVariableBounds(node.typeParameters);
 
     // Setup the supertype for the element (if there is a cycle in the
     // class hierarchy, it has already been set to Object).
     if (element.supertype == null && node.superclass != null) {
       MixinApplication superMixin = node.superclass.asMixinApplication();
       if (superMixin != null) {
-        DartType supertype = resolveSupertype(element, superMixin.superclass);
+        ResolutionDartType supertype =
+            resolveSupertype(element, superMixin.superclass);
         Link<Node> link = superMixin.mixins.nodes;
         while (!link.isEmpty) {
           supertype =
               applyMixin(supertype, checkMixinType(link.head), link.head);
           link = link.tail;
         }
         element.supertype = supertype;
       } else {
         element.supertype = resolveSupertype(element, node.superclass);
       }
@@ skipping 59 matching lines @@
             constructor,
             reporter.createMessage(node, erroneousElement.messageKind,
                 erroneousElement.messageArguments));
       }
       element.setDefaultConstructor(constructor, reporter);
     }
     return element.computeType(resolution);
   }
 
   @override
-  DartType visitEnum(Enum node) {
+  ResolutionDartType visitEnum(Enum node) {
     if (element == null) {
       throw reporter.internalError(node, 'element is null');
     }
     if (element.resolutionState != STATE_STARTED) {
       throw reporter.internalError(
           element, 'cyclic resolution of class $element');
     }
 
-    InterfaceType enumType = element.computeType(resolution);
+    ResolutionInterfaceType enumType = element.computeType(resolution);
     element.supertype = objectType;
-    element.interfaces = const Link<DartType>();
+    element.interfaces = const Link<ResolutionDartType>();
     calculateAllSupertypes(element);
 
     if (node.names.nodes.isEmpty) {
       reporter.reportErrorMessage(
           node, MessageKind.EMPTY_ENUM_DECLARATION, {'enumName': element.name});
     }
 
     EnumCreator creator =
         new EnumCreator(reporter, resolution.commonElements, element);
     creator.createMembers();
     return enumType;
   }
 
   /// Resolves the mixed type for [mixinNode] and checks that the mixin type
   /// is a valid, non-blacklisted interface type. The mixin type is returned.
-  DartType checkMixinType(TypeAnnotation mixinNode) {
-    DartType mixinType = resolveType(mixinNode);
+  ResolutionDartType checkMixinType(TypeAnnotation mixinNode) {
+    ResolutionDartType mixinType = resolveType(mixinNode);
     if (isBlackListed(mixinType)) {
       reporter.reportErrorMessage(
           mixinNode, MessageKind.CANNOT_MIXIN, {'type': mixinType});
     } else if (mixinType.isTypeVariable) {
       reporter.reportErrorMessage(mixinNode, MessageKind.CLASS_NAME_EXPECTED);
     } else if (mixinType.isMalformed) {
       reporter.reportErrorMessage(mixinNode, MessageKind.CANNOT_MIXIN_MALFORMED,
           {'className': element.name, 'malformedType': mixinType});
     } else if (mixinType.isEnumType) {
       reporter.reportErrorMessage(mixinNode, MessageKind.CANNOT_MIXIN_ENUM,
           {'className': element.name, 'enumType': mixinType});
     }
     return mixinType;
   }
 
-  DartType visitNamedMixinApplication(NamedMixinApplication node) {
+  ResolutionDartType visitNamedMixinApplication(NamedMixinApplication node) {
     if (element == null) {
       throw reporter.internalError(node, 'element is null');
     }
     if (element.resolutionState != STATE_STARTED) {
       throw reporter.internalError(
           element, 'cyclic resolution of class $element');
     }
 
     element.computeType(resolution);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     // Generate anonymous mixin application elements for the
     // intermediate mixin applications (excluding the last).
-    DartType supertype = resolveSupertype(element, node.superclass);
+    ResolutionDartType supertype = resolveSupertype(element, node.superclass);
     Link<Node> link = node.mixins.nodes;
     while (!link.tail.isEmpty) {
       supertype = applyMixin(supertype, checkMixinType(link.head), link.head);
       link = link.tail;
     }
     doApplyMixinTo(element, supertype, checkMixinType(link.head));
     return element.computeType(resolution);
   }
 
-  DartType applyMixin(DartType supertype, DartType mixinType, Node node) {
+  ResolutionDartType applyMixin(
+      ResolutionDartType supertype, ResolutionDartType mixinType, Node node) {
     String superName = supertype.name;
     String mixinName = mixinType.name;
     MixinApplicationElementX mixinApplication =
         new UnnamedMixinApplicationElementX("${superName}+${mixinName}",
             element, resolution.idGenerator.getNextFreeId(), node);
     // Create synthetic type variables for the mixin application.
-    List<DartType> typeVariables = <DartType>[];
+    List<ResolutionDartType> typeVariables = <ResolutionDartType>[];
     int index = 0;
-    for (TypeVariableType type in element.typeVariables) {
+    for (ResolutionTypeVariableType type in element.typeVariables) {
       TypeVariableElementX typeVariableElement = new TypeVariableElementX(
           type.name, mixinApplication, index, type.element.node);
-      TypeVariableType typeVariable = new TypeVariableType(typeVariableElement);
+      ResolutionTypeVariableType typeVariable =
+          new ResolutionTypeVariableType(typeVariableElement);
       typeVariables.add(typeVariable);
       index++;
     }
     // Setup bounds on the synthetic type variables.
-    for (TypeVariableType type in element.typeVariables) {
-      TypeVariableType typeVariable = typeVariables[type.element.index];
+    for (ResolutionTypeVariableType type in element.typeVariables) {
+      ResolutionTypeVariableType typeVariable =
+          typeVariables[type.element.index];
       TypeVariableElementX typeVariableElement = typeVariable.element;
       typeVariableElement.typeCache = typeVariable;
       typeVariableElement.boundCache =
           type.element.bound.subst(typeVariables, element.typeVariables);
     }
     // Setup this and raw type for the mixin application.
     mixinApplication.computeThisAndRawType(resolution, typeVariables);
     // Substitute in synthetic type variables in super and mixin types.
     supertype = supertype.subst(typeVariables, element.typeVariables);
     mixinType = mixinType.subst(typeVariables, element.typeVariables);
 
     doApplyMixinTo(mixinApplication, supertype, mixinType);
     mixinApplication.resolutionState = STATE_DONE;
     mixinApplication.supertypeLoadState = STATE_DONE;
     // Replace the synthetic type variables by the original type variables in
     // the returned type (which should be the type actually extended).
-    InterfaceType mixinThisType = mixinApplication.thisType;
+    ResolutionInterfaceType mixinThisType = mixinApplication.thisType;
     return mixinThisType.subst(
         element.typeVariables, mixinThisType.typeArguments);
   }
 
   bool isDefaultConstructor(FunctionElement constructor) {
     if (constructor.name != '') return false;
     constructor.computeType(resolution);
     return constructor.functionSignature.parameterCount == 0;
   }
 
   FunctionElement createForwardingConstructor(
       ConstructorElement target, ClassElement enclosing) {
     FunctionElement constructor =
         new SynthesizedConstructorElementX.notForDefault(
             target.name, target, enclosing);
     constructor.computeType(resolution);
     return constructor;
   }
 
   void doApplyMixinTo(MixinApplicationElementX mixinApplication,
-      DartType supertype, DartType mixinType) {
+      ResolutionDartType supertype, ResolutionDartType mixinType) {
     Node node = mixinApplication.parseNode(resolution.parsingContext);
 
     if (mixinApplication.supertype != null) {
       // [supertype] is not null if there was a cycle.
       assert(invariant(node, reporter.hasReportedError));
       supertype = mixinApplication.supertype;
       assert(invariant(node, supertype.isObject));
     } else {
       mixinApplication.supertype = supertype;
     }
 
     // Named mixin application may have an 'implements' clause.
     NamedMixinApplication namedMixinApplication =
         node.asNamedMixinApplication();
-    Link<DartType> interfaces = (namedMixinApplication != null)
+    Link<ResolutionDartType> interfaces = (namedMixinApplication != null)
         ? resolveInterfaces(
             namedMixinApplication.interfaces, namedMixinApplication.superclass)
-        : const Link<DartType>();
+        : const Link<ResolutionDartType>();
 
     // The class that is the result of a mixin application implements
     // the interface of the class that was mixed in so always prepend
     // that to the interface list.
     if (mixinApplication.interfaces == null) {
       if (mixinType.isInterfaceType) {
         // Avoid malformed types in the interfaces.
         interfaces = interfaces.prepend(mixinType);
       }
       mixinApplication.interfaces = interfaces;
     } else {
       assert(
           invariant(mixinApplication, mixinApplication.hasIncompleteHierarchy));
     }
 
     ClassElement superclass = supertype.element;
-    if (mixinType.kind != TypeKind.INTERFACE) {
+    if (mixinType.kind != ResolutionTypeKind.INTERFACE) {
       mixinApplication.hasIncompleteHierarchy = true;
       mixinApplication.allSupertypesAndSelf = superclass.allSupertypesAndSelf;
       return;
     }
 
     assert(mixinApplication.mixinType == null);
     mixinApplication.mixinType = resolveMixinFor(mixinApplication, mixinType);
 
     // Create forwarding constructors for constructor defined in the superclass
     // because they are now hidden by the mixin application.
     superclass.forEachLocalMember((Element member) {
       if (!member.isGenerativeConstructor) return;
       FunctionElement forwarder =
           createForwardingConstructor(member, mixinApplication);
       if (Name.isPrivateName(member.name) &&
           mixinApplication.library != superclass.library) {
         // Do not create a forwarder to the super constructor, because the mixin
         // application is in a different library than the constructor in the
         // super class and it is not possible to call that constructor from the
         // library using the mixin application.
         return;
       }
       mixinApplication.addConstructor(forwarder);
     });
     calculateAllSupertypes(mixinApplication);
   }
 
-  InterfaceType resolveMixinFor(
-      MixinApplicationElement mixinApplication, DartType mixinType) {
+  ResolutionInterfaceType resolveMixinFor(
+      MixinApplicationElement mixinApplication, ResolutionDartType mixinType) {
     ClassElement mixin = mixinType.element;
     mixin.ensureResolved(resolution);
 
     // Check for cycles in the mixin chain.
     ClassElement previous = mixinApplication; // For better error messages.
     ClassElement current = mixin;
     while (current != null && current.isMixinApplication) {
       MixinApplicationElement currentMixinApplication = current;
       if (currentMixinApplication == mixinApplication) {
         reporter.reportErrorMessage(
             mixinApplication,
             MessageKind.ILLEGAL_MIXIN_CYCLE,
             {'mixinName1': current.name, 'mixinName2': previous.name});
         // We have found a cycle in the mixin chain. Return null as
         // the mixin for this application to avoid getting into
         // infinite recursion when traversing members.
         return null;
       }
       previous = current;
       current = currentMixinApplication.mixin;
     }
     return mixinType;
   }
 
-  DartType resolveType(TypeAnnotation node) {
+  ResolutionDartType resolveType(TypeAnnotation node) {
     return typeResolver.resolveTypeAnnotation(this, node);
   }
 
-  DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
-    DartType supertype = resolveType(superclass);
+  ResolutionDartType resolveSupertype(
+      ClassElement cls, TypeAnnotation superclass) {
+    ResolutionDartType supertype = resolveType(superclass);
     if (supertype != null) {
       if (supertype.isMalformed) {
         reporter.reportErrorMessage(
             superclass,
             MessageKind.CANNOT_EXTEND_MALFORMED,
             {'className': element.name, 'malformedType': supertype});
         return objectType;
       } else if (supertype.isEnumType) {
         reporter.reportErrorMessage(superclass, MessageKind.CANNOT_EXTEND_ENUM,
             {'className': element.name, 'enumType': supertype});
         return objectType;
       } else if (!supertype.isInterfaceType) {
         reporter.reportErrorMessage(
             superclass.typeName, MessageKind.CLASS_NAME_EXPECTED);
         return objectType;
       } else if (isBlackListed(supertype)) {
         reporter.reportErrorMessage(
             superclass, MessageKind.CANNOT_EXTEND, {'type': supertype});
         return objectType;
       }
     }
     return supertype;
   }
 
-  Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
-    Link<DartType> result = const Link<DartType>();
+  Link<ResolutionDartType> resolveInterfaces(
+      NodeList interfaces, Node superclass) {
+    Link<ResolutionDartType> result = const Link<ResolutionDartType>();
     if (interfaces == null) return result;
     for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
-      DartType interfaceType = resolveType(link.head);
+      ResolutionDartType interfaceType = resolveType(link.head);
       if (interfaceType != null) {
         if (interfaceType.isMalformed) {
           reporter.reportErrorMessage(
               link.head,
               MessageKind.CANNOT_IMPLEMENT_MALFORMED,
               {'className': element.name, 'malformedType': interfaceType});
         } else if (interfaceType.isEnumType) {
           reporter.reportErrorMessage(
               link.head,
               MessageKind.CANNOT_IMPLEMENT_ENUM,
@@ skipping 40 matching lines @@
    *   supertypes(C) = [S, I1, I2] ++ supertypes(S) ++ supertypes(I1)
    *                   ++ supertypes(I2),
    * where ++ stands for list concatenation.
    *
    * This order makes sure that if a class implements an interface twice with
    * different type arguments, the type used in the most specific class comes
    * first.
    */
   void calculateAllSupertypes(BaseClassElementX cls) {
     if (cls.allSupertypesAndSelf != null) return;
-    final DartType supertype = cls.supertype;
+    final ResolutionDartType supertype = cls.supertype;
     if (supertype != null) {
       cls.allSupertypesAndSelf = new OrderedTypeSetBuilder(cls,
               reporter: reporter, objectType: commonElements.objectType)
           .createOrderedTypeSet(supertype, cls.interfaces);
     } else {
       assert(cls == resolution.commonElements.objectClass);
       cls.allSupertypesAndSelf =
           new OrderedTypeSet.singleton(cls.computeType(resolution));
     }
   }
 
-  isBlackListed(DartType type) {
+  isBlackListed(ResolutionDartType type) {
     LibraryElement lib = element.library;
     return !identical(lib, resolution.commonElements.coreLibrary) &&
         !resolution.target.isTargetSpecificLibrary(lib) &&
         (type.isDynamic ||
             type == commonElements.boolType ||
             type == commonElements.numType ||
             type == commonElements.intType ||
             type == commonElements.doubleType ||
             type == commonElements.stringType ||
             type == commonElements.nullType);
@@ skipping 80 matching lines @@
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType) {
       reporter.reportErrorMessage(node.selector,
           MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }