Prefix resolution_types with Resolution.

pkg/compiler/lib/src/resolution/class_members.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.
 
 library dart2js.resolution.compute_members;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers, Names;
 import '../common/resolution.dart' show Resolution;
 import '../elements/resolution_types.dart';
@@ skipping 81 matching lines @@
   /// If [name] and [names] are not null, the computation is restricted to
   /// members with these names.
   void computeSuperMembers(String name, Setlet<Name> names);
 
   /// Compute the members of the super class of [cls] and store them in
   /// [classMembers].
   ///
   /// If [name] and [names] are not null, the computation is restricted to
   /// members with these names.
   void computeSuperClassMembers(String name, Setlet<Name> names) {
-    InterfaceType supertype = cls.supertype;
+    ResolutionInterfaceType supertype = cls.supertype;
     if (supertype == null) return;
     ClassElement superclass = supertype.element;
 
     // Inherit class and interface members from superclass.
     void inheritClassMember(DeclaredMember member) {
       if (shouldSkipMember(member)) return;
       if (!member.isStatic) {
         DeclaredMember inherited = member.inheritFrom(supertype);
         classMembers[member.name] = inherited;
       }
@@ skipping 42 matching lines @@
             inheritMixinMember(
                 mixinApplication.mixin.lookupClassMember(memberName));
           }
         } else {
           computeAllClassMembers(resolution, mixinApplication.mixin);
           mixinApplication.mixin.forEachClassMember(inheritMixinMember);
         }
       }
     } else {
       LibraryElement library = cls.library;
-      InterfaceType thisType = cls.thisType;
+      ResolutionInterfaceType thisType = cls.thisType;
 
       void createMember(MemberElement element) {
         if (element.isConstructor) return;
         String elementName = element.name;
         if (shouldSkipName(elementName)) return;
         if (nameText != null && elementName != nameText) return;
 
-        void addDeclaredMember(
-            Name name, DartType type, FunctionType functionType) {
+        void addDeclaredMember(Name name, ResolutionDartType type,
+            ResolutionFunctionType functionType) {
           DeclaredMember inherited = classMembers[name];
           DeclaredMember declared;
           if (element.isAbstract) {
             declared = new DeclaredAbstractMember(
                 name, element, thisType, type, functionType, inherited);
           } else {
             declared =
                 new DeclaredMember(name, element, thisType, type, functionType);
           }
           declaredMembers[name] = declared;
           classMembers[name] = declared;
           checkValidOverride(declared, inherited);
         }
 
         Name name = new Name(element.name, library);
         if (element.isField) {
-          DartType type = element.computeType(resolution);
-          addDeclaredMember(name, type, new FunctionType.synthesized(type));
+          ResolutionDartType type = element.computeType(resolution);
+          addDeclaredMember(
+              name, type, new ResolutionFunctionType.synthesized(type));
           if (!element.isConst && !element.isFinal) {
             addDeclaredMember(
                 name.setter,
                 type,
-                new FunctionType.synthesized(
-                    const VoidType(), <DartType>[type]));
+                new ResolutionFunctionType.synthesized(
+                    const ResolutionVoidType(), <ResolutionDartType>[type]));
           }
         } else if (element.isGetter) {
-          FunctionType functionType = element.computeType(resolution);
-          DartType type = functionType.returnType;
+          ResolutionFunctionType functionType = element.computeType(resolution);
+          ResolutionDartType type = functionType.returnType;
           addDeclaredMember(name, type, functionType);
         } else if (element.isSetter) {
-          FunctionType functionType = element.computeType(resolution);
-          DartType type;
+          ResolutionFunctionType functionType = element.computeType(resolution);
+          ResolutionDartType type;
           if (!functionType.parameterTypes.isEmpty) {
             type = functionType.parameterTypes.first;
           } else {
-            type = const DynamicType();
+            type = const ResolutionDynamicType();
           }
           name = name.setter;
           addDeclaredMember(name, type, functionType);
         } else {
           assert(invariant(element, element.isFunction));
-          FunctionType type = element.computeType(resolution);
+          ResolutionFunctionType type = element.computeType(resolution);
           addDeclaredMember(name, type, type);
         }
       }
 
       cls.forEachLocalMember(createMember);
       if (cls.isPatched) {
         cls.implementation.forEachLocalMember((Element element) {
           if (element.isDeclaration) {
             createMember(element);
           }
@@ skipping 146 matching lines @@
           reportMessage(inherited.element, MessageKind.NO_STATIC_OVERRIDE, () {
             reportErrorWithContext(
                 declared.element,
                 MessageKind.NO_STATIC_OVERRIDE,
                 inherited.element,
                 MessageKind.NO_STATIC_OVERRIDE_CONT);
           });
         }
       }
 
-      DartType declaredType = declared.functionType;
+      ResolutionDartType declaredType = declared.functionType;
       for (Member inherited in superMember.declarations) {
         if (inherited.element == declared.element) {
           // TODO(ahe): For some reason, "call" elements are repeated in
           // superMember.declarations. Investigate why.
         } else if (cls == inherited.declarer.element) {
           // An error should already have been reported.
           assert(
               invariant(declared.element, resolution.reporter.hasReportedError,
                   message: "Member $inherited inherited from its "
                       "declaring class: ${cls}."));
@@ skipping 24 matching lines @@
         } else if (declared.isMethod && inherited.isDeclaredByField) {
           reportError(MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD,
               MessageKind.CANNOT_OVERRIDE_FIELD_WITH_METHOD_CONT);
         } else if (declared.isGetter && inherited.isMethod) {
           reportError(MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER,
               MessageKind.CANNOT_OVERRIDE_METHOD_WITH_GETTER_CONT);
         } else if (declared.isMethod && inherited.isGetter) {
           reportError(MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD,
               MessageKind.CANNOT_OVERRIDE_GETTER_WITH_METHOD_CONT);
         } else {
-          DartType inheritedType = inherited.functionType;
+          ResolutionDartType inheritedType = inherited.functionType;
           if (!resolution.types.isSubtype(declaredType, inheritedType)) {
             void reportWarning(
                 var marker, MessageKind warningKind, MessageKind infoKind) {
               reportMessage(marker, MessageKind.INVALID_OVERRIDE_METHOD, () {
                 reporter.reportWarning(
                     reporter.createMessage(declared.element, warningKind, {
                       'declaredType': declared.type,
                       'name': declared.name.text,
                       'class': cls.thisType,
                       'inheritedType': inherited.type,
@@ skipping 149 matching lines @@
   /// If [name] and [names] are not null, the computation is restricted to
   /// members with these names.
   Map<Name, Setlet<Member>> computeSuperMembers(
       String name, Setlet<Name> names) {
     computeSuperClassMembers(name, names);
     return computeSuperInterfaceMembers(name, names);
   }
 
   Map<Name, Setlet<Member>> computeSuperInterfaceMembers(
       String name, Setlet<Name> names) {
-    InterfaceType supertype = cls.supertype;
+    ResolutionInterfaceType supertype = cls.supertype;
     assert(invariant(cls, supertype != null,
         message: "Interface members computed for $cls."));
     ClassElement superclass = supertype.element;
 
     Map<Name, Setlet<Member>> inheritedInterfaceMembers =
         new Map<Name, Setlet<Member>>();
 
     void inheritInterfaceMember(
-        InterfaceType supertype, MemberSignature member) {
+        ResolutionInterfaceType supertype, MemberSignature member) {
       if (shouldSkipMember(member)) return;
       Setlet<Member> members = inheritedInterfaceMembers.putIfAbsent(
           member.name, () => new Setlet<Member>());
       for (DeclaredMember declaredMember in member.declarations) {
         members.add(declaredMember.inheritFrom(supertype));
       }
     }
 
-    void inheritInterfaceMembers(InterfaceType supertype) {
+    void inheritInterfaceMembers(ResolutionInterfaceType supertype) {
       supertype.element.forEachInterfaceMember((MemberSignature member) {
         inheritInterfaceMember(supertype, member);
       });
     }
 
     if (names != null) {
       for (Name memberName in names) {
         inheritInterfaceMember(
             supertype, superclass.lookupInterfaceMember(memberName));
       }
     } else {
       inheritInterfaceMembers(supertype);
     }
 
     // Inherit interface members from superinterfaces.
-    for (Link<DartType> link = cls.interfaces;
+    for (Link<ResolutionDartType> link = cls.interfaces;
         !link.isEmpty;
         link = link.tail) {
-      InterfaceType superinterface = link.head;
+      ResolutionInterfaceType superinterface = link.head;
       if (names != null) {
         MembersCreator._computeClassMember(
             resolution, superinterface.element, name, names);
         for (Name memberName in names) {
           inheritInterfaceMember(superinterface,
               superinterface.element.lookupInterfaceMember(memberName));
         }
       } else {
         MembersCreator.computeAllClassMembers(
             resolution, superinterface.element);
@@ skipping 15 matching lines @@
       checkInterfaceMember(name, interfaceMember, classMember);
     });
   }
 
   /// Compute the interface members of [cls] given the set of inherited
   /// interface members [inheritedInterfaceMembers] and declared members
   /// [declaredMembers]. The computed members are stored in [interfaceMembers].
   void computeInterfaceMembers(
       Map<Name, Setlet<Member>> inheritedInterfaceMembers,
       Map<Name, Member> declaredMembers) {
-    InterfaceType thisType = cls.thisType;
+    ResolutionInterfaceType thisType = cls.thisType;
     // Compute the interface members by overriding the inherited members with
     // a declared member or by computing a single, possibly synthesized,
     // inherited member.
     inheritedInterfaceMembers
         .forEach((Name name, Setlet<Member> inheritedMembers) {
       Member declared = declaredMembers[name];
       if (declared != null) {
         // Check that [declaredMember] is a valid override
         for (Member inherited in inheritedMembers) {
           checkValidOverride(declared, inherited);
         }
         if (!declared.isStatic) {
           interfaceMembers[name] = declared;
         }
       } else if (inheritedMembers.length == 1) {
         interfaceMembers[name] = inheritedMembers.single;
       } else {
         bool someAreGetters = false;
         bool allAreGetters = true;
-        Map<DartType, Setlet<Member>> subtypesOfAllInherited =
-            new Map<DartType, Setlet<Member>>();
+        Map<ResolutionDartType, Setlet<Member>> subtypesOfAllInherited =
+            new Map<ResolutionDartType, Setlet<Member>>();
         outer:
         for (Member inherited in inheritedMembers) {
           if (inherited.isGetter) {
             someAreGetters = true;
             if (!allAreGetters) break outer;
           } else {
             allAreGetters = false;
             if (someAreGetters) break outer;
           }
           for (MemberSignature other in inheritedMembers) {
@@ skipping 63 matching lines @@
     int minRequiredParameters;
     int maxPositionalParameters;
     Set<String> names = new Set<String>();
     for (MemberSignature member in inheritedMembers) {
       int requiredParameters = 0;
       int optionalParameters = 0;
       if (member.isSetter) {
         requiredParameters = 1;
       }
       if (member.type.isFunctionType) {
-        FunctionType type = member.type;
+        ResolutionFunctionType type = member.type;
         type.namedParameters.forEach((String name) => names.add(name));
         requiredParameters = type.parameterTypes.length;
         optionalParameters = type.optionalParameterTypes.length;
       }
       int positionalParameters = requiredParameters + optionalParameters;
       if (minRequiredParameters == null ||
           minRequiredParameters > requiredParameters) {
         minRequiredParameters = requiredParameters;
       }
       if (maxPositionalParameters == null ||
           maxPositionalParameters < positionalParameters) {
         maxPositionalParameters = positionalParameters;
       }
     }
     int optionalParameters = maxPositionalParameters - minRequiredParameters;
     // TODO(johnniwinther): Support function types with both optional
     // and named parameters?
     if (optionalParameters == 0 || names.isEmpty) {
-      DartType dynamic = const DynamicType();
-      List<DartType> requiredParameterTypes =
+      ResolutionDartType dynamic = const ResolutionDynamicType();
+      List<ResolutionDartType> requiredParameterTypes =
           new List.filled(minRequiredParameters, dynamic);
-      List<DartType> optionalParameterTypes =
+      List<ResolutionDartType> optionalParameterTypes =
           new List.filled(optionalParameters, dynamic);
       List<String> namedParameters = names.toList()
         ..sort((a, b) => a.compareTo(b));
-      List<DartType> namedParameterTypes =
+      List<ResolutionDartType> namedParameterTypes =
           new List.filled(namedParameters.length, dynamic);
-      FunctionType memberType = new FunctionType.synthesized(
-          const DynamicType(),
-          requiredParameterTypes,
-          optionalParameterTypes,
-          namedParameters,
-          namedParameterTypes);
-      DartType type = memberType;
+      ResolutionFunctionType memberType =
+          new ResolutionFunctionType.synthesized(
+              const ResolutionDynamicType(),
+              requiredParameterTypes,
+              optionalParameterTypes,
+              namedParameters,
+              namedParameterTypes);
+      ResolutionDartType type = memberType;
       if (inheritedMembers.first.isGetter || inheritedMembers.first.isSetter) {
-        type = const DynamicType();
+        type = const ResolutionDynamicType();
       }
       interfaceMembers[name] =
           new SyntheticMember(inheritedMembers, type, memberType);
     }
   }
 }
 
 abstract class ClassMemberMixin implements ClassElement {
   /// When [classMembers] and [interfaceMembers] have not been fully computed
   /// [computedMembersNames] holds the names for which members have already been
@@ skipping 133 matching lines @@
         message: "Members have not been fully computed for $this."));
     if (interfaceMembersAreClassMembers) {
       classMembers.forEach((_, member) {
         if (!member.isStatic) f(member);
       });
     } else {
       interfaceMembers.forEach((_, member) => f(member));
     }
   }
 }