Introduce typed selectors to do better tree shaking based on calls on 'this'. Getters and setters w…

lib/compiler/implementation/universe.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.
 
 class Universe {
   Map<Element, String> generatedCode;
   Map<Element, String> generatedBailoutCode;
   final Set<ClassElement> instantiatedClasses;
   final Set<SourceString> instantiatedClassInstanceFields;
   final Set<FunctionElement> staticFunctionsNeedingGetter;
@@ skipping 60 matching lines @@
       const Selector(SelectorKind.INDEX, 2);
   static final Selector GETTER_AND_SETTER =
       const Selector(SelectorKind.SETTER, 1);
   static final Selector INVOCATION_0 =
       const Selector(SelectorKind.INVOCATION, 0);
   static final Selector INVOCATION_1 =
       const Selector(SelectorKind.INVOCATION, 1);
   static final Selector INVOCATION_2 =
       const Selector(SelectorKind.INVOCATION, 2);
 
-  bool applies(FunctionParameters parameters) {
+  bool applies(FunctionElement element, Compiler compiler) {
+    FunctionParameters parameters = element.computeParameters(compiler);
     if (argumentCount > parameters.parameterCount) return false;
     int requiredParameterCount = parameters.requiredParameterCount;
     int optionalParameterCount = parameters.optionalParameterCount;
     if (positionalArgumentCount < requiredParameterCount) return false;
 
     bool hasOptionalParameters = !parameters.optionalParameters.isEmpty();
     if (namedArguments.isEmpty()) {
       if (!hasOptionalParameters) {
         return requiredParameterCount == argumentCount;
       } else {
@@ skipping 22 matching lines @@
       return true;
     }
   }
 
   /**
    * Returns [:true:] if the selector and the [element] match; [:false:]
    * otherwise.
    */
   bool addArgumentsToList(Link<Node> arguments,
                           List list,
-                          FunctionParameters parameters,
+                          FunctionElement element,
                           compileArgument(Node argument),
-                          compileConstant(Element element)) {
-    void addMatchingArgumentsToList(Link<Node> link) {
-    }
+                          compileConstant(Element element),
+                          Compiler compiler) {
+    if (!this.applies(element, compiler)) return false;
 
-    if (!this.applies(parameters)) return false;
+    void addMatchingArgumentsToList(Link<Node> link) {}
+
+    FunctionParameters parameters = element.computeParameters(compiler);
     if (this.positionalArgumentCount == parameters.parameterCount) {
       for (Link<Node> link = arguments; !link.isEmpty(); link = link.tail) {
         list.add(compileArgument(link.head));
       }
       return true;
     }
 
     // If there are named arguments, provide them in the order
     // expected by the called function, which is the source order.
 
@@ skipping 82 matching lines @@
     if (!orderedNamedArguments.isEmpty()) return orderedNamedArguments;
 
     List<SourceString> list = new List<SourceString>.from(namedArguments);
     list.sort((SourceString first, SourceString second) {
       return first.slowToString().compareTo(second.slowToString());
     });
     orderedNamedArguments = list;
     return orderedNamedArguments;
   }
 }
+
+/**
+ * A [TypedInvocation] is an invocation where we have information on
+ * the type of the receiver.
+ */
+class TypedInvocation extends Invocation {
+  /**
+   * The type of the receiver. Any subtype of that type can be the
+   * target of the invocation.
+   */
+  final Type receiverType;
+
+  TypedInvocation(this.receiverType, Selector selector)
+      : super(selector.argumentCount, selector.namedArguments);
+
+  bool applies(FunctionElement element, Compiler compiler) {
+    if (!element.enclosingElement.isClass()) return false;
+
+    ClassElement other = element.enclosingElement;
+    ClassElement self = receiverType.element;
+    if (!other.isSubclassOf(self)) return false;
+    return super.applies(element, compiler);
+    return false;
+  }
+
+  bool operator ==(other) {
+    if (other is !TypedInvocation) return false;
+    if (other.receiverType !== receiverType) return false;
+    return super == other;
+  }
+}