Prefix resolution_types with Resolution.

tests/compiler/dart2js/members_test.dart

 // Copyright (c) 2014, 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 members_test;
 
 import 'package:expect/expect.dart';
 import "package:async_helper/async_helper.dart";
 import 'type_test_helper.dart';
 import 'package:compiler/src/elements/resolution_types.dart';
 import "package:compiler/src/elements/elements.dart"
     show Element, ClassElement, MemberSignature, Name, PublicName, Member;
 import "package:compiler/src/resolution/class_members.dart"
     show MembersCreator, DeclaredMember, ErroneousMember, SyntheticMember;
 
 void main() {
   testClassMembers();
   testInterfaceMembers();
   testClassVsInterfaceMembers();
   testMixinMembers();
   testMixinMembersWithoutImplements();
 }
 
-MemberSignature getMember(InterfaceType cls, String name,
+MemberSignature getMember(ResolutionInterfaceType cls, String name,
     {bool isSetter: false, int checkType: CHECK_INTERFACE}) {
   Name memberName = new Name(name, cls.element.library, isSetter: isSetter);
   MemberSignature member = checkType == CHECK_CLASS
       ? cls.element.lookupClassMember(memberName)
       : cls.element.lookupInterfaceMember(memberName);
   if (member != null) {
     Expect.equals(memberName, member.name);
   }
   return member;
 }
@@ skipping 24 matching lines @@
  * to be synthesized for the corresponding members found on the type is
  * [synthesizedFrom] or  or [erroneousFrom], respectively.
  * Otherwise, if [declarer] is `null`, the declarer is checked to be [cls], and
  * if [declarer] is not `null`, the declarer is checked to be [declarer].
  * If [type] is `null` it is checked that the type of the member is also the
  * member type, otherwise the type is checked to be [type].
  *
  * If [isClassMember] is `true` it is checked that the member is also a class
  * member.
  */
-MemberSignature checkMember(InterfaceType cls, String name,
+MemberSignature checkMember(ResolutionInterfaceType cls, String name,
     {bool isStatic: false,
     bool isSetter: false,
     bool isGetter: false,
-    InterfaceType declarer,
-    DartType type,
-    FunctionType functionType,
-    InterfaceType inheritedFrom,
-    List<InterfaceType> synthesizedFrom,
-    List<InterfaceType> erroneousFrom,
+    ResolutionInterfaceType declarer,
+    ResolutionDartType type,
+    ResolutionFunctionType functionType,
+    ResolutionInterfaceType inheritedFrom,
+    List<ResolutionInterfaceType> synthesizedFrom,
+    List<ResolutionInterfaceType> erroneousFrom,
     int checkType: ALSO_CLASS_MEMBER}) {
   String memberKind = checkType == CHECK_CLASS ? 'class' : 'interface';
   MemberSignature member =
       getMember(cls, name, isSetter: isSetter, checkType: checkType);
   Expect.isNotNull(member, "No $memberKind member '$name' in $cls.");
   Name memberName = member.name;
   if (checkType == ALSO_CLASS_MEMBER) {
     MemberSignature classMember = cls.element.lookupClassMember(memberName);
     Expect.isNotNull(classMember, "No class member '$memberName' in $cls.");
     Expect.equals(member, classMember);
@@ skipping 17 matching lines @@
           "to interface members.");
       if (synthesizedFrom != null) {
         Expect.isTrue(
             member is SyntheticMember, "Member '$member' is not synthesized.");
       } else {
         Expect.isTrue(
             member is ErroneousMember, "Member '$member' is not erroneous.");
       }
       Set<MemberSignature> members = new Set<MemberSignature>();
       List from = synthesizedFrom != null ? synthesizedFrom : erroneousFrom;
-      for (InterfaceType type in from) {
+      for (ResolutionInterfaceType type in from) {
         DeclaredMember inheritedMember =
             type.element.lookupInterfaceMember(memberName);
         Expect.isNotNull(inheritedMember);
         members.add(inheritedMember.inheritFrom(type));
       }
       Expect.setEquals(members, member.declarations);
     } else if (declarer != null) {
       DeclaredMember declared = member;
       Expect.equals(
           declarer,
@@ skipping 16 matching lines @@
         Expect.equals(member.type, member.functionType,
             "Unexpected type of $memberKind member '$member'.");
       }
       Expect.equals(functionType, member.functionType,
           "Unexpected member type of $memberKind member '$member'.");
     }
   }
   return member;
 }
 
-void checkMemberCount(InterfaceType cls, int expectedCount,
+void checkMemberCount(ResolutionInterfaceType cls, int expectedCount,
     {bool interfaceMembers: true}) {
   int count = 0;
   if (interfaceMembers) {
     cls.element.forEachInterfaceMember((_) => count++);
   } else {
     cls.element.forEachClassMember((_) => count++);
   }
   Expect.equals(expectedCount, count);
 }
 
@@ skipping 20 matching lines @@
       void method(T t) {}
       static staticMethod() {}
       toString([T t]) {}
     }
     class C<S> extends B<S> {}
     class D extends C<int> {}
     class E extends D {}
     """,
               useMockCompiler: false)
           .then((env) {
-        InterfaceType bool_ = env['bool'];
-        InterfaceType String_ = env['String'];
-        InterfaceType num_ = env['num'];
-        InterfaceType int_ = env['int'];
-        DynamicType dynamic_ = env['dynamic'];
-        VoidType void_ = env['void'];
-        InterfaceType Type_ = env['Type'];
-        InterfaceType Invocation_ = env['Invocation'];
+        ResolutionInterfaceType bool_ = env['bool'];
+        ResolutionInterfaceType String_ = env['String'];
+        ResolutionInterfaceType num_ = env['num'];
+        ResolutionInterfaceType int_ = env['int'];
+        ResolutionDynamicType dynamic_ = env['dynamic'];
+        ResolutionVoidType void_ = env['void'];
+        ResolutionInterfaceType Type_ = env['Type'];
+        ResolutionInterfaceType Invocation_ = env['Invocation'];
 
-        InterfaceType Object_ = env['Object'];
+        ResolutionInterfaceType Object_ = env['Object'];
         checkMemberCount(Object_, 5 /*declared*/, interfaceMembers: true);
         checkMemberCount(Object_, 5 /*declared*/, interfaceMembers: false);
 
         checkMember(Object_, '==',
             functionType: env.functionType(bool_, [dynamic_]));
         checkMember(Object_, 'hashCode',
             isGetter: true,
             type: int_,
             functionType: env.functionType(int_, []));
         checkMember(Object_, 'noSuchMethod',
             functionType: env.functionType(dynamic_, [Invocation_]));
         checkMember(Object_, 'runtimeType',
             isGetter: true,
             type: Type_,
             functionType: env.functionType(Type_, []));
         checkMember(Object_, 'toString',
             functionType: env.functionType(String_, []));
 
-        InterfaceType A = env['A'];
+        ResolutionInterfaceType A = env['A'];
         MembersCreator.computeAllClassMembers(env.resolution, A.element);
 
         checkMemberCount(A, 5 /*inherited*/ + 9 /*non-static declared*/,
             interfaceMembers: true);
         checkMemberCount(
             A,
             5 /*inherited*/ +
                 9 /*non-abstract declared*/ +
                 3 /* abstract declared */,
             interfaceMembers: false);
@@ skipping 49 matching lines @@
         checkMember(A, 'method', functionType: env.functionType(dynamic_, []));
         checkMember(A, 'abstractMethod',
             functionType: env.functionType(dynamic_, []));
         checkMember(A, 'staticMethod',
             checkType: CHECK_CLASS,
             isStatic: true,
             functionType: env.functionType(dynamic_, []));
 
         ClassElement B = env.getElement('B');
         MembersCreator.computeAllClassMembers(env.resolution, B);
-        InterfaceType B_this = B.thisType;
-        TypeVariableType B_T = B_this.typeArguments.first;
+        ResolutionInterfaceType B_this = B.thisType;
+        ResolutionTypeVariableType B_T = B_this.typeArguments.first;
         checkMemberCount(B_this, 4 /*inherited*/ + 4 /*non-static declared*/,
             interfaceMembers: true);
         checkMemberCount(B_this, 4 /*inherited*/ + 5 /*declared*/,
             interfaceMembers: false);
 
         checkMember(B_this, '==', inheritedFrom: Object_);
         checkMember(B_this, 'hashCode', inheritedFrom: Object_);
         checkMember(B_this, 'noSuchMethod', inheritedFrom: Object_);
         checkMember(B_this, 'runtimeType', inheritedFrom: Object_);
 
         checkMember(B_this, 'field',
             isGetter: true, type: B_T, functionType: env.functionType(B_T, []));
         checkMember(B_this, 'field',
             isSetter: true,
             type: B_T,
             functionType: env.functionType(void_, [B_T]));
         checkMember(B_this, 'method',
             functionType: env.functionType(void_, [B_T]));
         checkMember(B_this, 'staticMethod',
             checkType: CHECK_CLASS,
             isStatic: true,
             functionType: env.functionType(dynamic_, []));
         checkMember(B_this, 'toString',
             functionType:
                 env.functionType(dynamic_, [], optionalParameters: [B_T]));
 
         ClassElement C = env.getElement('C');
         MembersCreator.computeAllClassMembers(env.resolution, C);
-        InterfaceType C_this = C.thisType;
-        TypeVariableType C_S = C_this.typeArguments.first;
+        ResolutionInterfaceType C_this = C.thisType;
+        ResolutionTypeVariableType C_S = C_this.typeArguments.first;
         checkMemberCount(C_this, 8 /*inherited*/, interfaceMembers: true);
         checkMemberCount(C_this, 8 /*inherited*/, interfaceMembers: false);
-        InterfaceType B_S = instantiate(B, [C_S]);
+        ResolutionInterfaceType B_S = instantiate(B, [C_S]);
 
         checkMember(C_this, '==', inheritedFrom: Object_);
         checkMember(C_this, 'hashCode', inheritedFrom: Object_);
         checkMember(C_this, 'noSuchMethod', inheritedFrom: Object_);
         checkMember(C_this, 'runtimeType', inheritedFrom: Object_);
 
         checkMember(C_this, 'field',
             isGetter: true,
             declarer: B_S,
             type: C_S,
             functionType: env.functionType(C_S, []));
         checkMember(C_this, 'field',
             isSetter: true,
             declarer: B_S,
             type: C_S,
             functionType: env.functionType(void_, [C_S]));
         checkMember(C_this, 'method',
             declarer: B_S, functionType: env.functionType(void_, [C_S]));
         checkMember(C_this, 'toString',
             declarer: B_S,
             functionType:
                 env.functionType(dynamic_, [], optionalParameters: [C_S]));
 
-        InterfaceType D = env['D'];
+        ResolutionInterfaceType D = env['D'];
         MembersCreator.computeAllClassMembers(env.resolution, D.element);
         checkMemberCount(D, 8 /*inherited*/, interfaceMembers: true);
         checkMemberCount(D, 8 /*inherited*/, interfaceMembers: false);
-        InterfaceType B_int = instantiate(B, [int_]);
+        ResolutionInterfaceType B_int = instantiate(B, [int_]);
 
         checkMember(D, '==', inheritedFrom: Object_);
         checkMember(D, 'hashCode', inheritedFrom: Object_);
         checkMember(D, 'noSuchMethod', inheritedFrom: Object_);
         checkMember(D, 'runtimeType', inheritedFrom: Object_);
 
         checkMember(D, 'field',
             isGetter: true,
             declarer: B_int,
             type: int_,
             functionType: env.functionType(int_, []));
         checkMember(D, 'field',
             isSetter: true,
             declarer: B_int,
             type: int_,
             functionType: env.functionType(void_, [int_]));
         checkMember(D, 'method',
             declarer: B_int, functionType: env.functionType(void_, [int_]));
         checkMember(D, 'toString',
             declarer: B_int,
             functionType:
                 env.functionType(dynamic_, [], optionalParameters: [int_]));
 
-        InterfaceType E = env['E'];
+        ResolutionInterfaceType E = env['E'];
         MembersCreator.computeAllClassMembers(env.resolution, E.element);
         checkMemberCount(E, 8 /*inherited*/, interfaceMembers: true);
         checkMemberCount(E, 8 /*inherited*/, interfaceMembers: false);
 
         checkMember(E, '==', inheritedFrom: Object_);
         checkMember(E, 'hashCode', inheritedFrom: Object_);
         checkMember(E, 'noSuchMethod', inheritedFrom: Object_);
         checkMember(E, 'runtimeType', inheritedFrom: Object_);
 
         checkMember(E, 'field',
@@ skipping 54 matching lines @@
       set setter2(num _);
       void set setter3(int _);
       getterAndMethod();
     }
     abstract class C {
       int method3();
       num method4();
     }
     abstract class D implements A, B, C {}
     """).then((env) {
-        DynamicType dynamic_ = env['dynamic'];
-        VoidType void_ = env['void'];
-        InterfaceType num_ = env['num'];
-        InterfaceType int_ = env['int'];
+        ResolutionDynamicType dynamic_ = env['dynamic'];
+        ResolutionVoidType void_ = env['void'];
+        ResolutionInterfaceType num_ = env['num'];
+        ResolutionInterfaceType int_ = env['int'];
 
-        InterfaceType A = env['A'];
-        InterfaceType B = env['B'];
-        InterfaceType C = env['C'];
-        InterfaceType D = env['D'];
+        ResolutionInterfaceType A = env['A'];
+        ResolutionInterfaceType B = env['B'];
+        ResolutionInterfaceType C = env['C'];
+        ResolutionInterfaceType D = env['D'];
 
         // Ensure that members have been computed on all classes.
         MembersCreator.computeAllClassMembers(env.resolution, D.element);
 
         // A: num method1()
         // B: int method1()
         // D: dynamic method1() -- synthesized from A and B.
         checkMember(D, 'method1',
             synthesizedFrom: [A, B],
             functionType: env.functionType(dynamic_, []),
@@ skipping 141 matching lines @@
     class A {
       method1() {}
       method2() {}
     }
     abstract class B {
       method1();
       method2(a);
     }
     abstract class C extends A implements B {}
     """).then((env) {
-        DynamicType dynamic_ = env['dynamic'];
-        VoidType void_ = env['void'];
-        InterfaceType num_ = env['num'];
-        InterfaceType int_ = env['int'];
+        ResolutionDynamicType dynamic_ = env['dynamic'];
+        ResolutionVoidType void_ = env['void'];
+        ResolutionInterfaceType num_ = env['num'];
+        ResolutionInterfaceType int_ = env['int'];
 
-        InterfaceType A = env['A'];
-        InterfaceType B = env['B'];
-        InterfaceType C = env['C'];
+        ResolutionInterfaceType A = env['A'];
+        ResolutionInterfaceType B = env['B'];
+        ResolutionInterfaceType C = env['C'];
 
         // Ensure that members have been computed on all classes.
         MembersCreator.computeAllClassMembers(env.resolution, C.element);
 
         // A: method1()
         // B: method1()
         // C class: method1() -- inherited from A.
         // C interface: dynamic method1() -- synthesized from A and B.
         MemberSignature interfaceMember = checkMember(C, 'method1',
             checkType: CHECK_INTERFACE,
@@ skipping 26 matching lines @@
       method3(T a) {}
       method4(T a) {}
     }
     abstract class B<S> {
       method1();
       method2(a);
       method3(S a) {}
     }
     abstract class C<U, V> extends Object with A<U> implements B<V> {}
     """).then((env) {
-        DynamicType dynamic_ = env['dynamic'];
-        VoidType void_ = env['void'];
-        InterfaceType num_ = env['num'];
-        InterfaceType int_ = env['int'];
+        ResolutionDynamicType dynamic_ = env['dynamic'];
+        ResolutionVoidType void_ = env['void'];
+        ResolutionInterfaceType num_ = env['num'];
+        ResolutionInterfaceType int_ = env['int'];
 
         ClassElement A = env.getElement('A');
         ClassElement B = env.getElement('B');
         ClassElement C = env.getElement('C');
-        InterfaceType C_this = C.thisType;
-        TypeVariableType C_U = C_this.typeArguments[0];
-        TypeVariableType C_V = C_this.typeArguments[1];
-        InterfaceType A_U = instantiate(A, [C_U]);
-        InterfaceType B_V = instantiate(B, [C_V]);
+        ResolutionInterfaceType C_this = C.thisType;
+        ResolutionTypeVariableType C_U = C_this.typeArguments[0];
+        ResolutionTypeVariableType C_V = C_this.typeArguments[1];
+        ResolutionInterfaceType A_U = instantiate(A, [C_U]);
+        ResolutionInterfaceType B_V = instantiate(B, [C_V]);
 
         // Ensure that members have been computed on all classes.
         MembersCreator.computeAllClassMembers(env.resolution, C);
 
         // A: method1()
         // B: method1()
         // C class: method1() -- inherited from A.
         // C interface: dynamic method1() -- synthesized from A and B.
         MemberSignature interfaceMember = checkMember(C_this, 'method1',
             checkType: CHECK_INTERFACE,
@@ skipping 39 matching lines @@
 
 void testMixinMembersWithoutImplements() {
   asyncTest(() => TypeEnvironment.create(r"""
     abstract class A {
       m();
     }
     abstract class B implements A {
     }
     abstract class C extends Object with B {}
     """).then((env) {
-        DynamicType dynamic_ = env['dynamic'];
-        VoidType void_ = env['void'];
-        InterfaceType num_ = env['num'];
-        InterfaceType int_ = env['int'];
+        ResolutionDynamicType dynamic_ = env['dynamic'];
+        ResolutionVoidType void_ = env['void'];
+        ResolutionInterfaceType num_ = env['num'];
+        ResolutionInterfaceType int_ = env['int'];
 
-        InterfaceType A = env['A'];
-        InterfaceType B = env['B'];
-        InterfaceType C = env['C'];
+        ResolutionInterfaceType A = env['A'];
+        ResolutionInterfaceType B = env['B'];
+        ResolutionInterfaceType C = env['C'];
 
         // Ensure that members have been computed on all classes.
         MembersCreator.computeAllClassMembers(env.resolution, C.element);
 
         checkMember(C, 'm',
             checkType: NO_CLASS_MEMBER,
             inheritedFrom: A,
             functionType: env.functionType(dynamic_, []));
       }));
 }