Introduce typed selectors for getters and setters also for better tree shaking.

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 1080 matching lines @@
           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);
-        if (method !== null) {
-          if (method.isFunction()) {
-            if (!method.modifiers.isAbstract()) {
-              // Make sure the method (whether in this class or in a
-              // superclass) is compiled.
-              // TODO(ngeoffray): Note that we could not emit this method
-              // if it is always being overridden and its holder is not
-              // instantiated.
-              compiler.registerDynamicInvocationOf(method);
-            }
-          } else {
-            // TODO(ngeoffray): better tree shaking on getters.
-            compiler.registerDynamicInvocation(node.name, node.selector);
-          }
-        }
         Type type = cls.computeType(compiler);
         compiler.registerDynamicInvocation(
-            node.name, new TypedInvocation(type, node.selector));
+            node.name, new TypedSelector(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);
     buffer.add('.');
     buffer.add(compiler.namer.setterName(currentLibrary, node.name));
     visitArguments(node.inputs);
-    compiler.registerDynamicSetter(node.name);
+    if (node.inputs[0] is HThis) {
+      ClassElement cls = work.element.enclosingElement;
+      Type type = cls.computeType(compiler);
+      compiler.registerDynamicSetter(node.name,
+          new TypedSelector(type, Selector.SETTER));
+    } else {
+      compiler.registerDynamicSetter(node.name, Selector.SETTER);
+    }
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(compiler.namer.getterName(currentLibrary, node.name));
     visitArguments(node.inputs);
-    compiler.registerDynamicGetter(node.name);
+    if (node.inputs[0] is HThis) {
+      ClassElement cls = work.element.enclosingElement;
+      Type type = cls.computeType(compiler);
+      compiler.registerDynamicGetter(node.name,
+          new TypedSelector(type, Selector.GETTER));
+    } else {
+      compiler.registerDynamicGetter(node.name, Selector.GETTER);
+    }
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeClosure(HInvokeClosure node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(compiler.namer.closureInvocationName(node.selector));
     visitArguments(node.inputs);
     // TODO(floitsch): we should have a separate list for closure invocations.
     compiler.registerDynamicInvocation(Namer.CLOSURE_INVOCATION_NAME,
                                        node.selector);
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeStatic(HInvokeStatic node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     use(node.target, JSPrecedence.CALL_PRECEDENCE);
     visitArguments(node.inputs);
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   visitInvokeSuper(HInvokeSuper node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     Element superMethod = node.element;
     Element superClass = superMethod.enclosingElement;
     // Remove the element and 'this'.
     int argumentCount = node.inputs.length - 2;
     String className = compiler.namer.isolatePropertyAccess(superClass);
-    String methodName;
     if (superMethod.kind == ElementKind.FUNCTION ||
         superMethod.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
-      methodName = compiler.namer.instanceMethodName(
+      String methodName = compiler.namer.instanceMethodName(
           currentLibrary, superMethod.name, argumentCount);
+      buffer.add('$className.prototype.$methodName.call');
+      visitArguments(node.inputs);
+    } else if (superMethod.kind == ElementKind.FIELD) {
+      buffer.add('this.${compiler.namer.getName(superMethod)}');
     } else {
-      methodName = compiler.namer.getterName(currentLibrary, superMethod.name);
-      // We need to register the name to ensure that the emitter
-      // generates the necessary getter.
-      // TODO(ahe): This is not optimal for tree-shaking, but we lack
-      // API to register the precise information. In this case, the
-      // enclosingElement of superMethod needs the getter, no other
-      // class (not even its subclasses).
-      compiler.registerDynamicGetter(superMethod.name);
+      assert(superMethod.kind == ElementKind.GETTER);
+      String methodName =
+          compiler.namer.getterName(currentLibrary, superMethod.name);
+      buffer.add('$className.prototype.$methodName.call()');
     }
-    buffer.add('$className.prototype.$methodName.call');
-    visitArguments(node.inputs);
     endExpression(JSPrecedence.CALL_PRECEDENCE);
     compiler.registerStaticUse(superMethod);
   }
 
   visitFieldGet(HFieldGet node) {
     if (node.receiver !== null) {
       String name =
           compiler.namer.instanceFieldName(currentLibrary, node.element.name);
       beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
       use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
@@ skipping 879 matching lines @@
       startBailoutSwitch();
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasGuards()) {
       endBailoutSwitch();
     }
   }
 }