A class can implement another class, so a selector on a class applies to a member that implements t…

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, CodeBuffer> generatedCode;
   Map<Element, CodeBuffer> generatedBailoutCode;
   final Set<ClassElement> instantiatedClasses;
   final Set<SourceString> instantiatedClassInstanceFields;
   final Set<FunctionElement> staticFunctionsNeedingGetter;
@@ skipping 357 matching lines @@
     // class A {
     //   get foo => () => 42;
     //   bar() => foo(); // The call to 'foo' is a typed selector.
     // }
     ClassElement other = element.getEnclosingClass();
     if (other.superclass === compiler.closureClass) {
       return appliesUntyped(element, compiler);
     }
 
     ClassElement self = receiverType.element;
-    // TODO(ngeoffray): tree-shake on interfaces.
-    if (self.isInterface() || other.isSubclassOf(self)) {
+    if (other.implementsInterface(self) || other.isSubclassOf(self)) {

[kasperl, 2012/08/29 11:57:36]

So this is essentially a subtype (not subclass) check? This is probably correct,
but I'm not sure it's optimal. I think we need to distinguish between two kinds
of typed selectors: One that is guaranteed to be invoked on a subclass of the
receiverType -- and one that can be invoked on any subtype of the receiverType. 

We can trivially use the subclass variant for calls on 'this' and in most cases
where we have concrete type information (here we can actually do better because
we know that it cannot even be a subclass), but for typed selectors introduced
because of data flow and 'is' checks we need the subtype variant.

Does that make sense?

[ngeoffray, 2012/08/29 12:13:50]

It does. I added another test to make sure we don't forget about this
optimization.

       return appliesUntyped(element, compiler);
     }
 
     if (!self.isInterface() && self.isSubclassOf(other)) {
       // Resolve an invocation of [element.name] on [self]. If it
       // is found, this selector is a candidate.
       return hasElementIn(self, element) && appliesUntyped(element, compiler);
     }
 
     return false;
   }
 
   toString() {
     return 'Selector($kind, "${name.slowToString()}", '
            '$argumentCount, type=$receiverType)';
   }
 }