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

lib/compiler/implementation/ssa/codegen.dart

Index: lib/compiler/implementation/ssa/codegen.dart
===================================================================
--- lib/compiler/implementation/ssa/codegen.dart	(revision 6835)
+++ lib/compiler/implementation/ssa/codegen.dart	(working copy)
@@ -1027,6 +1027,17 @@
         // If we know we're calling a specific method, register that
         // method only.
         compiler.registerDynamicInvocationOf(node.element);
+      } else if (node.inputs[0] is HThis) {
+        // TODO(ngeoffray): We should propagate an union type in
+        // earlier phases instead of just checking if the receiver is 'this'.
+        ClassElement cls = work.element.enclosingElement;
+        Element method = cls.lookupMember(node.name);

[floitsch, 2012/04/23 13:58:30]

Is this just to reduce the number of typed invocations?
Unless I'm wrong it yields more compiled methods:
class A { foo() => 42; }
class B extends A { ... foo() ... } // => cls = A.
class C extends A { foo() => 499; }
Since C is a subclass of 'cls' (A) we will compile C.foo, even though we could
have told that nobody actually invokes it.

[ngeoffray, 2012/04/23 14:09:33]

Yes.
Ok, so we need A.foo() to be compiled and actually just set the typed selector
to B. Does that make sense?

[floitsch, 2012/04/23 15:01:51]

Yes. I think that would be the more "correct" version. However reducing the
typed invocations might be quite beneficial. For now either version is ok with
me, but should be documented. If it doesn't cost too much I would prefer to go
with the one that prunes more first, and only if we have too many different
typed invocations switch to sharing.
Note that not sharing also simplifies the code.

[ngeoffray, 2012/04/23 15:22:47]

Added a comment.

+        if (method !== null) {
+          cls = method.enclosingElement;
+        }
+        Type type = cls.computeType(compiler);
+        compiler.registerDynamicInvocation(
+            node.name, new TypedInvocation(type, node.selector));
       } else {
         compiler.registerDynamicInvocation(node.name, node.selector);
       }