Revert "Implement .getCallType" and "Update status"

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);
-  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}');
-    }
-  }
+  Expect.isNotNull(
+      closedWorld1.getClassSet(cls1), "Missing ClassSet for $cls1");
+  Expect.isNotNull(
+      closedWorld2.getClassSet(cls2), "Missing ClassSet for $cls2");
 }
 
 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,
-    DartTypes types1, DartTypes types2, TestStrategy strategy,
+checkElementEnvironment(
+    ElementEnvironment env1, ElementEnvironment env2, 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;
     }
   }
 }