Implement reflective access to static methods.

dart/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:mirrors';
 
 import 'dart:_foreign_helper' show JS, JS_CURRENT_ISOLATE;
@@ skipping 289 matching lines @@
     }
     if (fields is! String) {
       // TODO(ahe): This is CSP mode.  Find a way to determine the
       // fields of this class.
       fields = '';
     }
   }
   var mirror = classMirrors[constructorOrInterceptor];
   if (mirror == null) {
     mirror = new JsClassMirror(
-        symbol, constructorOrInterceptor, fields, fieldsMetadata);
+        symbol, mangledName, constructorOrInterceptor, fields, fieldsMetadata);
     classMirrors[constructorOrInterceptor] = mirror;
   }
   return mirror;
 }
 
 abstract class JsObjectMirror implements ObjectMirror {
   Future<InstanceMirror> setFieldAsync(Symbol fieldName, Object value) {
     return new Future<InstanceMirror>(() => this.setField(fieldName, value));
   }
 
@@ skipping 74 matching lines @@
   }
 
   String toString() => 'InstanceMirror on ${Error.safeToString(reflectee)}';
 
   // TODO(ahe): Remove this method from the API.
   MirrorSystem get mirrors => currentJsMirrorSystem;
 }
 
 class JsClassMirror extends JsTypeMirror with JsObjectMirror
     implements ClassMirror {
+  final String _mangledName;
   final _jsConstructorOrInterceptor;
   final String _fields;
   final List _fieldsMetadata;
   List _metadata;
   JsClassMirror _superclass;
   List<JsMethodMirror> _cachedMethods;
 
   // Set as side-effect of accessing JsLibraryMirror.classes.
   JsLibraryMirror _owner;
 
   JsClassMirror(Symbol simpleName,
+                this._mangledName,
                 this._jsConstructorOrInterceptor,
                 this._fields,
                 this._fieldsMetadata)
       : super(simpleName);
 
   String get _prettyName => 'ClassMirror';
 
   get _jsConstructor {
     if (_jsConstructorOrInterceptor is Interceptor) {
       return JS('', '#.constructor', _jsConstructorOrInterceptor);
     } else {
       return _jsConstructorOrInterceptor;
     }
   }
 
   Map<Symbol, MethodMirror> get constructors {
-    Map<Symbol, MethodMirror> result = new Map<Symbol, MethodMirror>();
-    JsLibraryMirror library = owner;
-    String unmangledName = n(simpleName);
-    for (JsMethodMirror mirror in library._functionMirrors) {
-      Symbol name = mirror.simpleName;
-      if (mirror.isConstructor
-          && (name == simpleName || n(name).startsWith('$unmangledName.'))) {
-        result[name] = mirror;
-        mirror._owner = this;
+    var result = new Map<Symbol, MethodMirror>();
+    for (JsMethodMirror method in _methods) {
+      if (method.isConstructor) {
+        result[method.simpleName] = method;
       }
     }
     return result;
   }
 
   List<JsMethodMirror> get _methods {
     if (_cachedMethods != null) return _cachedMethods;
     var prototype = JS('', '#.prototype', _jsConstructor);
     List<String> keys = extractKeys(prototype);
     var result = <JsMethodMirror>[];
     for (String key in keys) {
       if (key == '') continue;
       String simpleName = mangledNames[key];
       // [simpleName] can be null if [key] represents an implementation
       // detail, for example, a bailout method, or runtime type support.
       // It might also be null if the user has limited what is reified for
       // reflection with metadata.
       if (simpleName == null) continue;
       var function = JS('', '#[#]', prototype, key);
       var mirror =
           new JsMethodMirror.fromUnmangledName(
               simpleName, function, false, false);
       result.add(mirror);
       mirror._owner = this;
     }
+
+    keys = extractKeys(JS('', 'init.statics[#]', _mangledName));
+    int length = keys.length;
+    for (int i = 0; i < length; i++) {
+      String mangledName = keys[i];
+      String unmangledName = mangledName;
+      // TODO(ahe): Create accessor for accessing $.  It is also
+      // used in js_helper.
+      var jsFunction = JS('', '#[#]', JS_CURRENT_ISOLATE(), mangledName);
+
+      bool isConstructor = false;
+      if (i + 1 < length) {
+        String reflectionName = keys[i + 1];
+        if (reflectionName.startsWith('+')) {
+          i++;
+          reflectionName = reflectionName.substring(1);
+          isConstructor = reflectionName.startsWith('new ');
+          if (isConstructor) {
+            reflectionName = reflectionName.substring(4).replaceAll(r'$', '.');
+          }
+        }
+        unmangledName = reflectionName;
+      }
+      bool isStatic = !isConstructor; // Constructors are not static.
+      JsMethodMirror mirror =
+          new JsMethodMirror.fromUnmangledName(
+              unmangledName, jsFunction, isStatic, isConstructor);
+      result.add(mirror);
+      mirror._owner = this;
+    }
+
     return _cachedMethods = result;
   }
 
   Map<Symbol, MethodMirror> get methods {
     var result = new Map<Symbol, MethodMirror>();
     for (JsMethodMirror method in _methods) {
-      if (!method.isGetter && !method.isSetter) {
+      if (!method.isConstructor && !method.isGetter && !method.isSetter) {
         result[method.simpleName] = method;
       }
     }
     return result;
   }
 
   Map<Symbol, MethodMirror> get getters {
     // TODO(ahe): This is a hack to remove getters corresponding to a field.
     var fields = variables;
 
@@ skipping 447 matching lines @@
   var metadataFunction = JS('', '#["@"]', victim);
   if (metadataFunction != null) return JS('', '#()', metadataFunction);
   String source = JS('String', 'Function.prototype.toString.call(#)', victim);
   int index = source.lastIndexOf(new RegExp('"[0-9,]*";?[ \n\r]*}'));
   if (index == -1) return const [];
   index++;
   int endQuote = source.indexOf('"', index);
   return source.substring(index, endQuote).split(',').map(int.parse).map(
       (int i) => JS('', 'init.metadata[#]', i)).toList();
 }