Allow intercepted calls to have typed selectors.

sdk/lib/_internal/compiler/implementation/enqueue.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.
 
 part of dart2js;
 
 class EnqueueTask extends CompilerTask {
   final ResolutionEnqueuer resolution;
   final CodegenEnqueuer codegen;
 
@@ skipping 301 matching lines @@
   void registerGetOfStaticFunction(FunctionElement element) {
     registerStaticUse(element);
     universe.staticFunctionsNeedingGetter.add(element);
   }
 
   void registerDynamicInvocation(SourceString methodName, Selector selector) {
     assert(selector != null);
     registerInvocation(methodName, selector);
   }
 
-  void registerDynamicInvocationOf(Element element) {
-    addToWorkList(element);
+  void registerDynamicInvocationOf(Element element, Selector selector) {

[kasperl, 2013/02/06 07:24:03]

So the selector here is always a call here? If so, it would be nice if you could
assert that because it makes it easier to understand the way you're dealing with
fields (only adding the getter).

[ngeoffray, 2013/02/06 08:11:55]

Yes, it's only a call selector. I added an assert and a comment.

+    if (element.isFunction()) {
+      addToWorkList(element);
+    } else {
+      assert(element.isAbstractField());
+      AbstractFieldElement field = element;
+      addToWorkList(field.getter);
+    }
+    // We also need to add the selector to the invoked names map,
+    // because the emitter uses that map to generate parameter stubs.
+    Set<Selector> selectors = universe.invokedNames.putIfAbsent(
+        element.name, () => new Set<Selector>());
+    selectors.add(selector);
   }
 
   void registerDynamicGetter(SourceString methodName, Selector selector) {
     registerInvokedGetter(methodName, selector);
   }
 
   void registerDynamicSetter(SourceString methodName, Selector selector) {
     registerInvokedSetter(methodName, selector);
   }
 
@@ skipping 104 matching lines @@
     addToWorkList(
         compiler.isolateHelperLibrary.find(Compiler.START_ROOT_ISOLATE));
     addToWorkList(compiler.isolateHelperLibrary.find(
         const SourceString('_currentIsolate')));
     addToWorkList(compiler.isolateHelperLibrary.find(
         const SourceString('_callInIsolate')));
   }
 
   void enableNoSuchMethod(Element element) {
     if (compiler.enabledNoSuchMethod) return;
+    Selector selector = new Selector.noSuchMethod();
     if (identical(element.getEnclosingClass(), compiler.objectClass)) {
-      registerDynamicInvocationOf(element);
+      registerDynamicInvocationOf(element, selector);
       return;
     }
     compiler.enabledNoSuchMethod = true;
-    Selector selector = new Selector.noSuchMethod();
     registerInvocation(Compiler.NO_SUCH_METHOD, selector);
 
     compiler.createInvocationMirrorElement =
         compiler.findHelper(Compiler.CREATE_INVOCATION_MIRROR);
     addToWorkList(compiler.createInvocationMirrorElement);
   }
 
   void forEach(f(WorkItem work)) {
     while (!queue.isEmpty) {
       // TODO(johnniwinther): Find an optimal process order for resolution.
@@ skipping 88 matching lines @@
     while(!queue.isEmpty) {
       // TODO(johnniwinther): Find an optimal process order for codegen.
       f(queue.removeLast());
     }
   }
 
   void _logSpecificSummary(log(message)) {
     log('Compiled ${universe.generatedCode.length} methods.');
   }
 }