Revert "Change TypeInference to handle super calls as direct invocations." and "Optimize needNoSuch…

pkg/compiler/lib/src/world.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.world;
 
 import 'closure.dart' show SynthesizedCallMethodElementX;
 import 'common/backend_api.dart' show BackendClasses;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
@@ skipping 710 matching lines @@
   @override
   bool hasElementIn(ClassElement cls, Selector selector, Element element) {
     // Use [:implementation:] of [element]
     // because our function set only stores declarations.
     Element result = findMatchIn(cls, selector);
     return result == null
         ? false
         : result.implementation == element.implementation;
   }
 
-  Element findMatchIn(ClassElement cls, Selector selector,
-      {ClassElement stopAtSuperclass}) {
+  Element findMatchIn(ClassElement cls, Selector selector) {
     // Use the [:implementation] of [cls] in case the found [element]
     // is in the patch class.
-    var result = cls.implementation
-        .lookupByName(selector.memberName, stopAt: stopAtSuperclass);
+    var result = cls.implementation.lookupByName(selector.memberName);
     return result;
   }
 
   /// Returns whether a [selector] call on an instance of [cls]
   /// will hit a method at runtime, and not go through [noSuchMethod].
-  bool hasConcreteMatch(ClassElement cls, Selector selector,
-      {ClassElement stopAtSuperclass}) {
+  bool hasConcreteMatch(ClassElement cls, Selector selector) {
     assert(invariant(cls, isInstantiated(cls),
         message: '$cls has not been instantiated.'));
     Element element = findMatchIn(cls, selector);
     if (element == null) return false;
 
     if (element.isAbstract) {
       ClassElement enclosingClass = element.enclosingClass;
       return hasConcreteMatch(enclosingClass.superclass, selector);
     }
     return selector.appliesUntyped(element);
   }
 
   @override
   bool needsNoSuchMethod(
       ClassElement base, Selector selector, ClassQuery query) {
-    /// Returns `true` if subclasses in the [rootNode] tree needs noSuchMethod
-    /// handling.
-    bool subclassesNeedNoSuchMethod(ClassHierarchyNode rootNode) {
-      if (!rootNode.isInstantiated) {
-        // No subclass needs noSuchMethod handling since they are all
-        // uninstantiated.
+    /// Returns `true` if [cls] is an instantiated class that does not have
+    /// a concrete method matching [selector].
+    bool needsNoSuchMethod(ClassElement cls) {
+      // We can skip uninstantiated subclasses.
+      if (!isInstantiated(cls)) {
         return false;
       }
-      ClassElement rootClass = rootNode.cls;
-      if (hasConcreteMatch(rootClass, selector)) {
-        // The root subclass has a concrete implementation so no subclass needs
-        // noSuchMethod handling.
-        return false;
-      } else if (rootNode.isDirectlyInstantiated) {
-        // The root class need noSuchMethod handling.
-        return true;
-      }
-      IterationStep result = rootNode.forEachSubclass((ClassElement subclass) {
-        if (hasConcreteMatch(subclass, selector, stopAtSuperclass: rootClass)) {
-          // Found a match - skip all subclasses.
-          return IterationStep.SKIP_SUBCLASSES;
-        } else {
-          // Stop fast - we found a need for noSuchMethod handling.
-          return IterationStep.STOP;
-        }
-      }, ClassHierarchyNode.DIRECTLY_INSTANTIATED, strict: true);
-      // We stopped fast so we need noSuchMethod handling.
-      return result == IterationStep.STOP;
+      // We can just skip abstract classes because we know no
+      // instance of them will be created at runtime, and
+      // therefore there is no instance that will require
+      // [noSuchMethod] handling.
+      return !cls.isAbstract && !hasConcreteMatch(cls, selector);
     }
 
-    ClassSet classSet = getClassSet(base);
-    ClassHierarchyNode node = classSet.node;
-    if (query == ClassQuery.EXACT) {
-      return node.isDirectlyInstantiated && !hasConcreteMatch(base, selector);
-    } else if (query == ClassQuery.SUBCLASS) {
-      return subclassesNeedNoSuchMethod(node);
+    bool baseNeedsNoSuchMethod = needsNoSuchMethod(base);
+    if (query == ClassQuery.EXACT || baseNeedsNoSuchMethod) {
+      return baseNeedsNoSuchMethod;
+    }
+
+    Iterable<ClassElement> subclassesToCheck;
+    if (query == ClassQuery.SUBTYPE) {
+      subclassesToCheck = strictSubtypesOf(base);
     } else {
-      if (subclassesNeedNoSuchMethod(node)) return true;
-      for (ClassHierarchyNode subtypeNode in classSet.subtypeNodes) {
-        if (subclassesNeedNoSuchMethod(subtypeNode)) return true;
-      }
-      return false;
+      assert(query == ClassQuery.SUBCLASS);
+      subclassesToCheck = strictSubclassesOf(base);
     }
+
+    return subclassesToCheck != null &&
+        subclassesToCheck.any(needsNoSuchMethod);
   }
 
   final Compiler _compiler;
   BackendClasses get backendClasses => _backend.backendClasses;
   JavaScriptBackend get _backend => _compiler.backend;
   CommonMasks get commonMasks => _compiler.commonMasks;
   final FunctionSet allFunctions;
   final Set<Element> functionsCalledInLoop = new Set<Element>();
   final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
 
@@ skipping 348 matching lines @@
   /// Only the class itself is included.
   EXACT,
 
   /// The class and all subclasses (transitively) are included.
   SUBCLASS,
 
   /// The class and all classes that implement or subclass it (transitively)
   /// are included.
   SUBTYPE,
 }