Implement .getCallType

tests/compiler/dart2js/equivalence/check_functions.dart

 // Copyright (c) 2017, 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.
 
 /// Equivalence test functions for data objects.
 
 library dart2js.equivalence.functions;
 
 import 'package:expect/expect.dart';
 import 'package:compiler/src/common/resolution.dart';
@@ skipping 195 matching lines @@
       }
       Expect.isFalse(
           child.isInstantiated,
           'Missing subclass ${child.cls} of ${node1.cls} in '
           '${node2.directSubclasses}');
     }
   }
   checkMixinUses(
       closedWorld1, closedWorld2, node1.cls, node2.cls, elementEquivalence,
       verbose: verbose);
-  Expect.isNotNull(
-      closedWorld1.getClassSet(cls1), "Missing ClassSet for $cls1");
-  Expect.isNotNull(
-      closedWorld2.getClassSet(cls2), "Missing ClassSet for $cls2");
+  ClassSet classSet1 = closedWorld1.getClassSet(cls1);
+  ClassSet classSet2 = closedWorld2.getClassSet(cls2);
+  Expect.isNotNull(classSet1, "Missing ClassSet for $cls1");
+  Expect.isNotNull(classSet2, "Missing ClassSet for $cls2");
+  checkClassSets(
+      closedWorld1, closedWorld2, classSet1, classSet2, elementEquivalence,
+      verbose: verbose, allowMissingClosureClasses: allowMissingClosureClasses);
+}
+
+void checkClassSets(
+    ClosedWorld closedWorld1,
+    ClosedWorld closedWorld2,
+    ClassSet classSet1,
+    ClassSet classSet2,
+    bool elementEquivalence(Entity a, Entity b),
+    {bool verbose: false,
+    bool allowMissingClosureClasses: false}) {
+  for (ClassHierarchyNode child in classSet1.subtypeNodes) {
+    bool found = false;
+    for (ClassHierarchyNode other in classSet2.subtypeNodes) {
+      ClassEntity child1 = child.cls;
+      ClassEntity child2 = other.cls;
+      if (elementEquivalence(child1, child2)) {
+        found = true;
+        break;
+      }
+    }
+    if (!found && (!child.cls.isClosure || !allowMissingClosureClasses)) {
+      if (child.isInstantiated) {
+        print('Missing subtype ${child.cls} of ${classSet1.cls} '
+            'in ${classSet2.subtypeNodes}');
+        print(closedWorld1.dump(
+            verbose ? closedWorld1.commonElements.objectClass : classSet1.cls));
+        print(closedWorld2.dump(
+            verbose ? closedWorld2.commonElements.objectClass : classSet2.cls));
+      }
+      Expect.isFalse(
+          child.isInstantiated,
+          'Missing subclass ${child.cls} of ${classSet1.cls} in '
+          '${classSet2.subtypeNodes}');
+    }
+  }
 }
 
 void checkMixinUses(
     ClosedWorld closedWorld1,
     ClosedWorld closedWorld2,
     ClassEntity class1,
     ClassEntity class2,
     bool elementEquivalence(Entity a, Entity b),
     {bool verbose: false}) {
   checkSets(closedWorld1.mixinUsesOf(class1), closedWorld2.mixinUsesOf(class2),
@@ skipping 217 matching lines @@
   check(usage1, usage2, 'isRuntimeTypeUsed', usage1.isRuntimeTypeUsed,
       usage2.isRuntimeTypeUsed);
   check(usage1, usage2, 'isIsolateInUse', usage1.isIsolateInUse,
       usage2.isIsolateInUse);
   check(usage1, usage2, 'isFunctionApplyUsed', usage1.isFunctionApplyUsed,
       usage2.isFunctionApplyUsed);
   check(usage1, usage2, 'isNoSuchMethodUsed', usage1.isNoSuchMethodUsed,
       usage2.isNoSuchMethodUsed);
 }
 
-checkElementEnvironment(
-    ElementEnvironment env1, ElementEnvironment env2, TestStrategy strategy,
+checkElementEnvironment(ElementEnvironment env1, ElementEnvironment env2,
+    DartTypes types1, DartTypes types2, TestStrategy strategy,
     {bool checkConstructorBodies: false}) {
   strategy.testElements(
       env1, env2, 'mainLibrary', env1.mainLibrary, env2.mainLibrary);
   strategy.testElements(
       env1, env2, 'mainFunction', env1.mainFunction, env2.mainFunction);
 
   checkMembers(MemberEntity member1, MemberEntity member2) {
     Expect.equals(env1.isDeferredLoadLibraryGetter(member1),
         env2.isDeferredLoadLibraryGetter(member2));
 
@@ skipping 75 matching lines @@
       check(
           cls1,
           cls2,
           'getEffectiveMixinClass',
           env1.getEffectiveMixinClass(cls1),
           env2.getEffectiveMixinClass(cls2),
           strategy.elementEquivalence);
 
       // TODO(johnniwinther): Check type variable bounds.
 
+      check(cls1, cls2, 'callType', types1.getCallType(thisType1),
+          types2.getCallType(thisType2), strategy.typeEquivalence);
+
       List<InterfaceType> supertypes1 = <InterfaceType>[];
       env1.forEachSupertype(cls1, supertypes1.add);
       List<InterfaceType> supertypes2 = <InterfaceType>[];
       env2.forEachSupertype(cls2, supertypes2.add);
       checkLists(supertypes1, supertypes2, 'supertypes on $cls1, $cls2',
           strategy.typeEquivalence);
 
       List<ClassEntity> mixins1 = <ClassEntity>[];
       env1.forEachMixin(cls1, mixins1.add);
       List<ClassEntity> mixins2 = <ClassEntity>[];
@@ skipping 615 matching lines @@
         print('  ${js.nodeToString(node1)}');
         print('  ${js.nodeToString(node2)}');
       }
       return expectedValue == label2;
     } else {
       labelsMap[label1] = label2;
       return true;
     }
   }
 }