Version 0.8.10.8

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:collection' show UnmodifiableListView;
 import 'dart:mirrors';
 
@@ skipping 186 matching lines @@
 
   int get hashCode {
     int code = 0x3FFFFFFF & (JsTypeVariableMirror).hashCode;
     code ^= 17 * simpleName.hashCode;
     code ^= 19 * owner.hashCode;
     return code;
   }
 
   String get _prettyName => 'TypeVariableMirror';
 
+  bool get isTopLevel => false;
+
   TypeMirror get upperBound {
     if (_cachedUpperBound != null) return _cachedUpperBound;
     return _cachedUpperBound = typeMirrorFromRuntimeTypeRepresentation(
         owner, getMetadata(_typeVariable.bound));
   }
 }
 
 class JsTypeMirror extends JsDeclarationMirror implements TypeMirror {
   JsTypeMirror(Symbol simpleName)
       : super(simpleName);
@@ skipping 331 matching lines @@
 Map<Symbol, MethodMirror> filterMethods(List<MethodMirror> methods) {
   var result = new Map();
   for (JsMethodMirror method in methods) {
     if (!method.isConstructor && !method.isGetter && !method.isSetter) {
       result[method.simpleName] = method;
     }
   }
   return result;
 }
 
+Map<Symbol, MethodMirror> filterConstructors(methods) {
+  var result = new Map();
+  for (JsMethodMirror method in methods) {
+    if (method.isConstructor) {
+      result[method.simpleName] = method;
+    }
+  }
+  return result;
+}
+
 Map<Symbol, MethodMirror> filterGetters(List<MethodMirror> methods,
                                         Map<Symbol, VariableMirror> fields) {
   var result = new Map();
   for (JsMethodMirror method in methods) {
     if (method.isGetter) {
 
       // TODO(ahe): This is a hack to remove getters corresponding to a field.
       if (fields[method.simpleName] != null) continue;
 
       result[method.simpleName] = method;
     }
   }
   return result;
 }
 
 Map<Symbol, MethodMirror> filterSetters(List<MethodMirror> methods,
-                                          Map<Symbol, VariableMirror> fields) {
+                                        Map<Symbol, VariableMirror> fields) {
   var result = new Map();
   for (JsMethodMirror method in methods) {
     if (method.isSetter) {
 
       // TODO(ahe): This is a hack to remove setters corresponding to a field.
       String name = n(method.simpleName);
       name = name.substring(0, name.length - 1); // Remove '='.
       if (fields[s(name)] != null) continue;
 
       result[method.simpleName] = method;
     }
   }
   return result;
 }
 
+Map<Symbol, Mirror> filterMembers(List<MethodMirror> methods,
+                                  Map<Symbol, VariableMirror> variables) {
+  Map<Symbol, Mirror> result = new Map.from(variables);
+  for (JsMethodMirror method in methods) {
+    if (method.isSetter) {
+      String name = n(method.simpleName);
+      name = name.substring(0, name.length - 1);
+      // Filter-out setters corresponding to variables.
+      if (result[s(name)] is VariableMirror) continue;
+    }
+    // Constructors aren't 'members'.
+    if (method.isConstructor) continue;
+    // Use putIfAbsent to filter-out getters corresponding to variables.
+    result.putIfAbsent(method.simpleName, () => method);
+  }
+  return result;
+}
+
 int counter = 0;
 
 ClassMirror reflectMixinApplication(mixinNames, String mangledName) {
   disableTreeShaking();
   var mixins = [];
   for (String mangledName in mixinNames) {
     mixins.add(reflectClassByMangledName(mangledName));
   }
   var it = mixins.iterator;
   it.moveNext();
@@ skipping 254 matching lines @@
    * [_cachedTypeArguments]. Due to type substitution of, for instance,
    * superclasses the mangled name of the class and hence this string is needed
    * after [_cachedTypeArguments] has been computed.
    *
    * If an integer is encountered as a type argument, it represents the type
    * variable at the corresponding entry in [emitter.globalMetadata].
    */
   String _typeArguments;
 
   UnmodifiableListView<TypeMirror> _cachedTypeArguments;
+  UnmodifiableMapView<Symbol, DeclarationMirror> _cachedDeclarations;
+  UnmodifiableMapView<Symbol, DeclarationMirror> _cachedMembers;
+  UnmodifiableMapView<Symbol, MethodMirror> _cachedConstructors;
   Map<Symbol, VariableMirror> _cachedVariables;
   Map<Symbol, MethodMirror> _cachedGetters;
   Map<Symbol, MethodMirror> _cachedSetters;
   Map<Symbol, MethodMirror> _cachedMethodsMap;
   List<JsMethodMirror> _cachedMethods;
   ClassMirror _superclass;
   List<ClassMirror> _cachedSuperinterfaces;
 
   JsTypeBoundClassMirror(JsClassMirror originalDeclaration, this._typeArguments)
       : _class = originalDeclaration,
@@ skipping 46 matching lines @@
           }
         } else {
           currentTypeArgument += character;
         }
       }
       addTypeArgument(currentTypeArgument);
     }
     return _cachedTypeArguments = new UnmodifiableListView(result);
   }
 
-  Map<Symbol, MethodMirror> get constructors => _class.constructors;
-
   List<JsMethodMirror> get _methods {
     if (_cachedMethods != null) return _cachedMethods;
     return _cachedMethods =_class._getMethodsWithOwner(this);
   }
 
   Map<Symbol, MethodMirror> get methods {
     if (_cachedMethodsMap != null) return _cachedMethodsMap;
     return _cachedMethodsMap = new UnmodifiableMapView<Symbol, MethodMirror>(
         filterMethods(_methods));
   }
 
+  Map<Symbol, MethodMirror> get constructors {
+    if (_cachedConstructors != null) return _cachedConstructors;
+    return _cachedConstructors =
+        new UnmodifiableMapView<Symbol, MethodMirror>(
+            filterConstructors(_methods));
+  }
+
   Map<Symbol, MethodMirror> get getters {
     if (_cachedGetters != null) return _cachedGetters;
     return _cachedGetters = new UnmodifiableMapView<Symbol, MethodMirror>(
         filterGetters(_methods, variables));
   }
 
   Map<Symbol, MethodMirror> get setters {
     if (_cachedSetters != null) return _cachedSetters;
     return _cachedSetters = new UnmodifiableMapView<Symbol, MethodMirror>(
         filterSetters(_methods, variables));
   }
 
   Map<Symbol, VariableMirror> get variables {
     if (_cachedVariables != null) return _cachedVariables;
     var result = new Map();
     for (JsVariableMirror mirror in  _class._getFieldsWithOwner(this)) {
       result[mirror.simpleName] = mirror;
     }
     return _cachedVariables =
         new UnmodifiableMapView<Symbol, VariableMirror>(result);
   }
 
-  Map<Symbol, Mirror> get members => _class.members;
+  Map<Symbol, DeclarationMirror> get members {
+    if (_cachedMembers != null) return _cachedMembers;
+    return _cachedMembers = new UnmodifiableMapView<Symbol, DeclarationMirror>(
+        filterMembers(_methods, variables));
+  }
+
+  Map<Symbol, DeclarationMirror> get declarations {
+    if (_cachedDeclarations != null) return _cachedDeclarations;
+    Map<Symbol, DeclarationMirror> result =
+        new Map<Symbol, DeclarationMirror>();
+    result.addAll(members);
+    result.addAll(constructors);
+    typeVariables.forEach((tv) => result[tv.simpleName] = tv);
+    return _cachedDeclarations =
+        new UnmodifiableMapView<Symbol, DeclarationMirror>(result);
+  }
 
   InstanceMirror setField(Symbol fieldName, Object arg) {
     return _class.setField(fieldName, arg);
   }
 
   InstanceMirror getField(Symbol fieldName) => _class.getField(fieldName);
 
   InstanceMirror newInstance(Symbol constructorName,
                              List positionalArguments,
                              [Map<Symbol, dynamic> namedArguments]) {
@@ skipping 85 matching lines @@
   get _jsConstructor {
     if (_jsConstructorOrInterceptor is Interceptor) {
       return JS('', '#.constructor', _jsConstructorOrInterceptor);
     } else {
       return _jsConstructorOrInterceptor;
     }
   }
 
   Map<Symbol, MethodMirror> get constructors {
     if (_cachedConstructors != null) return _cachedConstructors;
-    var result = new Map();
-    for (JsMethodMirror method in _methods) {
-      if (method.isConstructor) {
-        result[method.simpleName] = method;
-      }
-    }
     return _cachedConstructors =
-        new UnmodifiableMapView<Symbol, MethodMirror>(result);
+        new UnmodifiableMapView<Symbol, MethodMirror>(
+            filterConstructors(_methods));
   }
 
   List<JsMethodMirror> _getMethodsWithOwner(DeclarationMirror methodOwner) {
     var prototype = JS('', '#.prototype', _jsConstructor);
     List<String> keys = extractKeys(prototype);
     var result = <JsMethodMirror>[];
     for (String key in keys) {
       if (isReflectiveDataInPrototype(key)) continue;
       String simpleName = mangledNames[key];
       // [simpleName] can be null if [key] represents an implementation
@@ skipping 93 matching lines @@
     var result = new Map();
     for (JsVariableMirror mirror in _fields) {
       result[mirror.simpleName] = mirror;
     }
     return _cachedVariables =
         new UnmodifiableMapView<Symbol, VariableMirror>(result);
   }
 
   Map<Symbol, Mirror> get members {
     if (_cachedMembers != null) return _cachedMembers;
-    Map<Symbol, Mirror> result = new Map.from(variables);
-    for (JsMethodMirror method in _methods) {
-      if (method.isSetter) {
-        String name = n(method.simpleName);
-        name = name.substring(0, name.length - 1);
-        // Filter-out setters corresponding to variables.
-        if (result[s(name)] is VariableMirror) continue;
-      }
-      // Constructors aren't 'members'.
-      if (method.isConstructor) continue;
-      // Use putIfAbsent to filter-out getters corresponding to variables.
-      result.putIfAbsent(method.simpleName, () => method);
-    }
-    return _cachedMembers = new UnmodifiableMapView<Symbol, Mirror>(result);
+    return _cachedMembers = new UnmodifiableMapView<Symbol, Mirror>(
+        filterMembers(_methods, variables));
   }
 
   Map<Symbol, DeclarationMirror> get declarations {
     if (_cachedDeclarations != null) return _cachedDeclarations;
     var result = new Map<Symbol, DeclarationMirror>();
     addToResult(Symbol key, Mirror value) {
       result[key] = value;
     }
     members.forEach(addToResult);
     constructors.forEach(addToResult);
@@ skipping 841 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";
 }