Implement ObjectMirror.[]

sdk/lib/_internal/lib/js_mirrors.dart

 // Copyright (c) 2013, 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.
 
 library dart._js_mirrors;
 
 import 'dart:async';
 import 'dart:collection' show UnmodifiableListView;
 import 'dart:mirrors';
 
@@ skipping 403 matching lines @@
 
   List<InstanceMirror> get metadata {
     if (_cachedMetadata != null) return _cachedMetadata;
     preserveMetadata();
     return _cachedMetadata =
         new UnmodifiableListView<InstanceMirror>(_metadata.map(reflect));
   }
 
   // TODO(ahe): Test this getter.
   DeclarationMirror get owner => null;
+
+  Function operator [](Symbol selector) {
+    if (!functions.containsKey(selector)) return null;
+    return new _InvocationTrampoline(this, selector);
+  }
 }
 
 String n(Symbol symbol) => _symbol_dev.Symbol.getName(symbol);
 
 Symbol s(String name) {
   if (name == null) return null;
   return new _symbol_dev.Symbol.unvalidated(name);
 }
 
 Symbol setterSymbol(Symbol symbol) => s("${n(symbol)}=");
@@ skipping 179 matching lines @@
   ClassMirror get originalDeclaration => this;
 
   // TODO(ahe): Implement this.
   List<TypeVariableMirror> get typeVariables {
     throw new UnimplementedError();
   }
 
   List<TypeMirror> get typeArguments => new List();
 }
 
+// TODO(13766): Implement Function.
+class _InvocationTrampoline /*implements Function*/ {
+  ObjectMirror _receiver;
+  Symbol _selector;
+  _InvocationTrampoline(this._receiver, this._selector);
+  noSuchMethod(Invocation msg) {

[ahe, 2013/10/03 07:26:35]

In no way can we use "noSuchMethod" in implementation libraries.

The reason is that noSuchMethod has global impact on the compiler and negatively
impacts generated code.

Fortunately, I'm currently working on implementing InstanceMirror.getField for
methods. This implementation should do the right thing, also for this use case.

+    if (msg.memberName != #call) return super.noSuchMethod(msg);
+    return _receiver.invoke(_selector,
+                            msg.positionalArguments,
+                            msg.namedArguments);
+  }
+}
+
 abstract class JsObjectMirror implements ObjectMirror {
   Future<InstanceMirror> setFieldAsync(Symbol fieldName, Object value) {
     return new Future<InstanceMirror>(() => this.setField(fieldName, value));
   }
 
   Future<InstanceMirror> getFieldAsync(Symbol fieldName) {
     return new Future<InstanceMirror>(() => this.getField(fieldName));
   }
 
   Future<InstanceMirror> invokeAsync(Symbol memberName,
@@ skipping 135 matching lines @@
 
   InstanceMirror getField(Symbol fieldName) {
     String reflectiveName = n(fieldName);
     return _invoke(fieldName, JSInvocationMirror.GETTER, reflectiveName, []);
   }
 
   delegate(Invocation invocation) {
     return JSInvocationMirror.invokeFromMirror(invocation, reflectee);
   }
 
+  Function operator [](Symbol selector) {
+    bool found = false;
+    for (ClassMirror c = type; c != null; c = c.superclass) {
+      var target = c.methods[selector];
+      if (target != null && !target.isStatic) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) return null;
+    return new _InvocationTrampoline(this, selector);
+  }
+
   operator ==(other) {
     return other is JsInstanceMirror &&
            identical(reflectee, other.reflectee);
   }
 
   int get hashCode {
     // If the reflectee is a built-in type, use the base-level hashCode to
     // preserve the illusion that, e.g. doubles, with the same value are
     // identical. Otherwise, use the primitive identity hash to maintain
     // correctness even if a user-defined hashCode returns different values for
@@ skipping 537 matching lines @@
          typeMirrorFromRuntimeTypeRepresentation(JS('', 'init.metadata[#]',
                                                     typeVars[i+1]));
       var typeMirror =
           new JsTypeVariableMirror(s(typeVars[i]), upperBound, this);
       result.add(typeMirror);
     }
     return _cachedTypeVariables = new UnmodifiableListView(result);
   }
 
   List<TypeMirror> get typeArguments => new List();
+
+  Function operator [](Symbol selector) {
+    var target = methods[selector];
+    if (target == null || !target.isStatic) return null;
+    return new _InvocationTrampoline(this, selector);
+  }
 }
 
 class JsVariableMirror extends JsDeclarationMirror implements VariableMirror {
   static final int REFLECTION_MARKER = 45;
 
   // TODO(ahe): The values in these fields are virtually untested.
   final String _jsName;
   final bool isFinal;
   final bool isStatic;
   final _metadataFunction;
@@ skipping 602 matching lines @@
 
 // TODO(ahe): Remove this class and call noSuchMethod instead.
 class UnimplementedNoSuchMethodError extends Error
     implements NoSuchMethodError {
   final String _message;
 
   UnimplementedNoSuchMethodError(this._message);
 
   String toString() => "Unsupported operation: $_message";
 }