Normalize type masks to use the least upper instantiated subclass/type.

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/dart_types.dart';
 import "package:compiler/src/elements/elements.dart"
        show Element, ClassElement, MemberSignature, Name, PublicName,
             DeclaredMember, Member;
 import "package:compiler/src/resolution/class_members.dart"
-  show DeclaredMember, ErroneousMember, SyntheticMember;
+  show MembersCreator, DeclaredMember, ErroneousMember, SyntheticMember;
 
 void main() {
   testClassMembers();
   testInterfaceMembers();
   testClassVsInterfaceMembers();
   testMixinMembers();
   testMixinMembersWithoutImplements();
 }
 
 MemberSignature getMember(InterfaceType cls, String name,
@@ skipping 179 matching lines @@
                 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'];
+    MembersCreator.computeAllClassMembers(env.compiler, 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);
 
     checkMember(A, '==', inheritedFrom: Object_);
     checkMember(A, 'hashCode', inheritedFrom: Object_);
     checkMember(A, 'noSuchMethod', inheritedFrom: Object_);
     checkMember(A, 'runtimeType', inheritedFrom: Object_);
@@ skipping 23 matching lines @@
                 functionType: env.functionType(dynamic_, [dynamic_]));
 
     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.compiler, B);
     InterfaceType B_this = B.thisType;
     TypeVariableType 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.compiler, C);
     InterfaceType C_this = C.thisType;
     TypeVariableType 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]);
 
     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'];
+    MembersCreator.computeAllClassMembers(env.compiler, D.element);
     checkMemberCount(D, 8 /*inherited*/, interfaceMembers: true);
     checkMemberCount(D, 8 /*inherited*/, interfaceMembers: false);
     InterfaceType 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'];
+    MembersCreator.computeAllClassMembers(env.compiler, 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', isGetter: true,
                 declarer: B_int,
@@ skipping 61 matching lines @@
     DynamicType dynamic_ = env['dynamic'];
     VoidType void_ = env['void'];
     InterfaceType num_ = env['num'];
     InterfaceType int_ = env['int'];
 
     InterfaceType A = env['A'];
     InterfaceType B = env['B'];
     InterfaceType C = env['C'];
     InterfaceType D = env['D'];
 
+    // Ensure that members have been computed on all classes.
+    MembersCreator.computeAllClassMembers(env.compiler, 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_ , []),
         checkType: NO_CLASS_MEMBER);
 
     // A: void method2()
     // B: int method2()
@@ skipping 145 matching lines @@
 
     DynamicType dynamic_ = env['dynamic'];
     VoidType void_ = env['void'];
     InterfaceType num_ = env['num'];
     InterfaceType int_ = env['int'];
 
     InterfaceType A = env['A'];
     InterfaceType B = env['B'];
     InterfaceType C = env['C'];
 
+    // Ensure that members have been computed on all classes.
+    MembersCreator.computeAllClassMembers(env.compiler, 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,
                     synthesizedFrom: [A, B],
                     functionType: env.functionType(dynamic_ , []));
     MemberSignature classMember =
         checkMember(C, 'method1', checkType: CHECK_CLASS, inheritedFrom: A);
@@ skipping 38 matching lines @@
 
     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]);
 
+    // Ensure that members have been computed on all classes.
+    MembersCreator.computeAllClassMembers(env.compiler, 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,
                     synthesizedFrom: [A_U, B_V],
                     functionType: env.functionType(dynamic_ , []));
     MemberSignature classMember =
         checkMember(C_this, 'method1', checkType: CHECK_CLASS,
@@ skipping 48 matching lines @@
 
     DynamicType dynamic_ = env['dynamic'];
     VoidType void_ = env['void'];
     InterfaceType num_ = env['num'];
     InterfaceType int_ = env['int'];
 
     InterfaceType A = env['A'];
     InterfaceType B = env['B'];
     InterfaceType C = env['C'];
 
+    // Ensure that members have been computed on all classes.
+    MembersCreator.computeAllClassMembers(env.compiler, C.element);
+
     checkMember(C, 'm', checkType: NO_CLASS_MEMBER,
                 inheritedFrom: A,
                 functionType: env.functionType(dynamic_ , []));
   }));
 }