Revert "Don't generate forwarding hooks if all noSuchMethod implementations"

pkg/compiler/lib/src/js_backend/no_such_method_registry.dart

-// Copyright (c) 2015, 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.
-
-part of js_backend;
-
-/**
- * Categorizes `noSuchMethod` implementations.
- *
- * If user code includes `noSuchMethod` implementations, type inference is
- * hindered because (for instance) any selector where the type of the
- * receiver is not known all implementations of `noSuchMethod` must be taken
- * into account when inferring the return type.
- *
- * The situation can be ameliorated with some heuristics for disregarding some
- * `noSuchMethod` implementations during type inference. We can partition
- * `noSuchMethod` implementations into 3 categories.
- *
- * Implementations in category A are the default implementations
- * `Object.noSuchMethod` and `Interceptor.noSuchMethod`.
- *
- * Implementations in category B syntactically immediately throw, for example:
- *
- *     noSuchMethod(x) => throw 'not implemented'
- *
- * Implementations that do not fall into category A or B are in category C. They
- * are the only category of implementation that are considered during type
- * inference.
- *
- * Implementations that syntactically just forward to the super implementation,
- * for example:
- *
- *     noSuchMethod(x) => super.noSuchMethod(x);
- *
- * are in the same category as the superclass implementation. This covers a
- * common case, where users implement `noSuchMethod` with these dummy
- * implementations to avoid warnings.
- */
-class NoSuchMethodRegistry {
-  /// The implementations that fall into category A, described above.
-  final Set<FunctionElement> defaultImpls = new Set<FunctionElement>();
-  /// The implementations that fall into category B, described above.
-  final Set<FunctionElement> throwingImpls = new Set<FunctionElement>();
-  /// The implementations that fall into category C, described above.
-  final Set<Element> otherImpls = new Set<Element>();
-
-  /// The implementations that have not yet been categorized.
-  final Set<Element> uncategorizedImpls = new Set<Element>();
-
-  final JavaScriptBackend backend;
-  final Compiler compiler;
-
-  NoSuchMethodRegistry(JavaScriptBackend backend)
-      : this.backend = backend,
-        this.compiler = backend.compiler;
-
-  bool get hasThrowingNoSuchMethod => throwingImpls.isNotEmpty;
-  bool get hasComplexNoSuchMethod => otherImpls.isNotEmpty;
-
-  void registerNoSuchMethod(Element noSuchMethodElement) {
-    uncategorizedImpls.add(noSuchMethodElement);
-  }
-
-  void onQueueEmpty() {
-    uncategorizedImpls.forEach(_categorizeImpl);
-    uncategorizedImpls.clear();
-  }
-
-  NsmCategory _categorizeImpl(Element noSuchMethodElement) {
-    assert(noSuchMethodElement.name == Compiler.NO_SUCH_METHOD);
-    if (defaultImpls.contains(noSuchMethodElement)) {
-      return NsmCategory.DEFAULT;
-    }
-    if (throwingImpls.contains(noSuchMethodElement)) {
-      return NsmCategory.THROWING;
-    }
-    if (otherImpls.contains(noSuchMethodElement)) {
-      return NsmCategory.OTHER;
-    }
-    if (noSuchMethodElement is! FunctionElement ||
-        !compiler.noSuchMethodSelector.signatureApplies(noSuchMethodElement)) {
-      otherImpls.add(noSuchMethodElement);
-      return NsmCategory.OTHER;
-    }
-    FunctionElement noSuchMethodFunc = noSuchMethodElement as FunctionElement;
-    if (backend.isDefaultNoSuchMethodImplementation(noSuchMethodFunc)) {
-      defaultImpls.add(noSuchMethodFunc);
-      return NsmCategory.DEFAULT;
-    } else if (hasForwardingSyntax(noSuchMethodFunc)) {
-      // If the implementation is 'noSuchMethod(x) => super.noSuchMethod(x);'
-      // then it is in the same category as the super call.
-      Element superCall = noSuchMethodFunc.enclosingClass
-          .lookupSuperSelector(compiler.noSuchMethodSelector);
-      NsmCategory category = _categorizeImpl(superCall);
-      switch(category) {
-        case NsmCategory.DEFAULT:
-          defaultImpls.add(noSuchMethodFunc);
-          break;
-        case NsmCategory.THROWING:
-          throwingImpls.add(noSuchMethodFunc);
-          break;
-        case NsmCategory.OTHER:
-          otherImpls.add(noSuchMethodFunc);
-          break;
-      }
-      return category;
-    } else if (isThrowing(noSuchMethodFunc)) {
-      throwingImpls.add(noSuchMethodFunc);
-      return NsmCategory.THROWING;
-    } else {
-      otherImpls.add(noSuchMethodFunc);
-      return NsmCategory.OTHER;
-    }
-  }
-
-  bool hasForwardingSyntax(FunctionElement element) {
-    String param = element.parameters.single.name;
-    Statement body = element.node.body;
-    Expression expr;
-    if (body is Return && body.isArrowBody) {
-      expr = body.expression;
-    } else if (body is Block &&
-        !body.statements.isEmpty &&
-        body.statements.nodes.tail.isEmpty) {
-      Statement stmt = body.statements.nodes.head;
-      if (stmt is Return && stmt.hasExpression) {
-        expr = stmt.expression;
-      }
-    }
-    if (expr is Send &&
-        expr.isSuperCall &&
-        expr.selector is Identifier &&
-        (expr.selector as Identifier).source == Compiler.NO_SUCH_METHOD) {
-      var arg = expr.arguments.head;
-      if (arg is Send &&
-          arg.argumentsNode == null &&
-          arg.receiver == null &&
-          arg.selector is Identifier &&
-          arg.selector.source == param) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  bool isThrowing(FunctionElement element) {
-    Statement body = element.node.body;
-    if (body is Return && body.isArrowBody) {
-      if (body.expression is Throw) {
-        return true;
-      }
-    } else if (body is Block &&
-        !body.statements.isEmpty &&
-        body.statements.nodes.tail.isEmpty) {
-      if (body.statements.nodes.head is Throw) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
-
-enum NsmCategory { DEFAULT, THROWING, OTHER }