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

lib/compiler/implementation/ssa/codegen.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 SsaCodeGeneratorTask extends CompilerTask {
   SsaCodeGeneratorTask(Compiler compiler) : super(compiler);
   String get name() => 'SSA code generator';
 
 
   String generateMethod(WorkItem work, HGraph graph) {
@@ skipping 1009 matching lines @@
       node.name.printOn(buffer);
       visitArguments(node.inputs);
     } else {
       buffer.add(compiler.namer.instanceMethodInvocationName(
           currentLibrary, node.name, node.selector));
       visitArguments(node.inputs);
       if (node.element !== null) {
         // 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);
       }
     }
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
@@ skipping 912 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endElse(HIf node) {
     if (node.elseBlock.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }