Revert "Remove implementation of deprecated mirror API from the VM."

runtime/lib/mirrors_impl.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.
 
 // VM-specific implementation of the dart:mirrors library.
 
 import "dart:collection";
 
 final emptyList = new UnmodifiableListView([]);
 final emptyMap = new _UnmodifiableMapView({});
@@ skipping 230 matching lines @@
 
   int get hashCode {
     // Avoid hash collisions with the reflectee. This constant is in Smi range
     // and happens to be the inner padding from RFC 2104.
     return identityHashCode(_reflectee) ^ 0x36363636;
   }
 
   Function operator [](Symbol selector) {
     bool found = false;
     for (ClassMirror c = type; c != null; c = c.superclass) {
-      var target = c._methods[selector];
+      var target = c.methods[selector];
       if (target != null && !target.isStatic && target.isRegularMethod) {
         found = true;
         break;
       }
     }
     if (!found) {
       throw new ArgumentError(
           "${MirrorSystem.getName(type.simpleName)} has no instance method "
           "${MirrorSystem.getName(selector)}");
     }
@@ skipping 68 matching lines @@
         arguments[argumentIndex++] = value;
         names[nameIndex++] = _n(name);
       });
     }
 
     // It is tempting to implement this in terms of Function.apply, but then
     // lazy compilation errors would be fatal.
     return reflect(_apply(arguments, names));
   }
 
+  Future<InstanceMirror> applyAsync(List positionalArguments,
+                                    [Map<Symbol, dynamic> namedArguments]) {
+    return new Future(() {
+      return this.apply(_unwrapAsyncPositionals(positionalArguments),
+                        _unwrapAsyncNamed(namedArguments));
+    });
+  }
+
   InstanceMirror findInContext(Symbol name, {ifAbsent: null}) {
     List<String> parts = _n(name).split(".").toList(growable: false);
     if (parts.length > 3) {
       throw new ArgumentError("Invalid symbol: ${name}");
     }
     List tuple = _computeFindInContext(_reflectee, parts);
     if (tuple.length == 0) {
       throw new UnsupportedError(
           "ClosureMirror.findInContext not yet supported");
     }
@@ skipping 139 matching lines @@
         }
       }
     }
     return _mixin;
   }
 
   Map<Symbol, DeclarationMirror> _declarations;
   Map<Symbol, DeclarationMirror> get declarations {
     if (_declarations != null) return _declarations;
     var decls = new Map<Symbol, DeclarationMirror>();
-    decls.addAll(_members);
-    decls.addAll(_constructors);
+    decls.addAll(members);
+    decls.addAll(constructors);
     typeVariables.forEach((tv) => decls[tv.simpleName] = tv);
     return _declarations =
         new _UnmodifiableMapView<Symbol, DeclarationMirror>(decls);
   }
 
-  Map<Symbol, Mirror> _cachedMembers;
-  Map<Symbol, Mirror> get _members {
-    if (_cachedMembers == null) {
+  Map<Symbol, Mirror> _members;
+  Map<Symbol, Mirror> get members {
+    if (_members == null) {
       var whoseMembers = _isMixinAlias ? _trueSuperclass : this;
-      _cachedMembers = _makeMemberMap(mixin._computeMembers(whoseMembers._reflectee));
+      _members = _makeMemberMap(mixin._computeMembers(whoseMembers._reflectee));
     }
-    return _cachedMembers;
+    return _members;
   }
 
-  Map<Symbol, MethodMirror> _cachedMethods;
-  Map<Symbol, MethodMirror> get _methods {
-    if (_cachedMethods == null) {
-      _cachedMethods = _filterMap(
-          _members,
+  Map<Symbol, MethodMirror> _methods;
+  Map<Symbol, MethodMirror> get methods {
+    if (_methods == null) {
+      _methods = _filterMap(
+          members,
           (key, value) => (value is MethodMirror && value.isRegularMethod));
     }
-    return _cachedMethods;
+    return _methods;
   }
 
-  Map<Symbol, MethodMirror> _cachedConstructors;
-  Map<Symbol, MethodMirror> get _constructors {
-    if (_cachedConstructors == null) {
+  Map<Symbol, MethodMirror> _getters;
+  Map<Symbol, MethodMirror> get getters {
+    if (_getters == null) {
+      _getters = _filterMap(
+          members,
+          (key, value) => (value is MethodMirror && value.isGetter));
+    }
+    return _getters;
+  }
+
+  Map<Symbol, MethodMirror> _setters;
+  Map<Symbol, MethodMirror> get setters {
+    if (_setters == null) {
+      _setters = _filterMap(
+          members,
+          (key, value) => (value is MethodMirror && value.isSetter));
+    }
+    return _setters;
+  }
+
+  Map<Symbol, VariableMirror> _variables;
+  Map<Symbol, VariableMirror> get variables {
+    if (_variables == null) {
+      _variables = _filterMap(
+          members,
+          (key, value) => (value is VariableMirror));
+    }
+    return _variables;
+  }
+
+  Map<Symbol, MethodMirror> _constructors;
+  Map<Symbol, MethodMirror> get constructors {
+    if (_constructors == null) {
       var constructorsList = _computeConstructors(_reflectee);
       var stringName = _n(simpleName);
       constructorsList.forEach((c) => c._patchConstructorName(stringName));
-      _cachedConstructors = _makeMemberMap(constructorsList);
+      _constructors = _makeMemberMap(constructorsList);
     }
-    return _cachedConstructors;
+    return _constructors;
   }
 
   bool get _isAnonymousMixinApplication {
     if (_isMixinAlias) return false;  // Named mixin application.
     if (mixin == this) return false;  // Not a mixin application.
     return true;
   }
 
   List<TypeVariableMirror> _typeVariables = null;
   List<TypeVariableMirror> get typeVariables {
@@ skipping 33 matching lines @@
     if (isOriginalDeclaration) {
       return this;
     } else {
       return reflectClass(_reflectedType);
     }
   }
 
   String toString() => "ClassMirror on '${MirrorSystem.getName(simpleName)}'";
 
   Function operator [](Symbol selector) {
-    var target = _methods[selector];
+    var target = methods[selector];
     if (target == null || !target.isStatic || !target.isRegularMethod) {
       throw new ArgumentError(
           "${MirrorSystem.getName(simpleName)} has no static method "
           "${MirrorSystem.getName(selector)}");
     }
     return new _InvocationTrampoline(this, selector);
   }
 
   InstanceMirror newInstance(Symbol constructorName,
                              List positionalArguments,
@@ skipping 15 matching lines @@
       });
     }
 
     return reflect(_invokeConstructor(_reflectee,
                                       _reflectedType,
                                       _n(constructorName),
                                       arguments,
                                       names));
   }
 
+  Future<InstanceMirror> newInstanceAsync(Symbol constructorName,
+                                          List positionalArguments,
+                                          [Map<Symbol, dynamic> namedArguments]) {
+    return new Future(() {
+      return this.newInstance(constructorName,
+                              _unwrapAsyncPositionals(positionalArguments),
+                              _unwrapAsyncNamed(namedArguments));
+    });
+  }
+
   List<InstanceMirror> get metadata {
     // Get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list.
     return new UnmodifiableListView(_metadata(_reflectee).map(reflect));
   }
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
            this._reflectee == other._reflectee &&
            this._reflectedType == other._reflectedType &&
@@ skipping 308 matching lines @@
   Type get _instantiator => null;
 
   SourceLocation get location {
     throw new UnimplementedError('LibraryMirror.location is not implemented');
   }
 
   Map<Symbol, DeclarationMirror> _declarations;
   Map<Symbol, DeclarationMirror> get declarations {
     if (_declarations != null) return _declarations;
     return _declarations =
-        new _UnmodifiableMapView<Symbol, DeclarationMirror>(_members);
+        new _UnmodifiableMapView<Symbol, DeclarationMirror>(members);
   }
 
-  Map<Symbol, Mirror> _cachedMembers;
-  Map<Symbol, Mirror> get _members {
-    if (_cachedMembers == null) {
-      _cachedMembers = _makeMemberMap(_computeMembers(_reflectee));
+  Map<Symbol, Mirror> _members;
+  Map<Symbol, Mirror> get members {
+    if (_members == null) {
+      _members = _makeMemberMap(_computeMembers(_reflectee));
     }
-    return _cachedMembers;
+    return _members;
   }
 
-  Map<Symbol, MethodMirror> _cachedFunctions;
-  Map<Symbol, MethodMirror> get _functions {
-    if (_cachedFunctions == null) {
-      _cachedFunctions = _filterMap(_members, (key, value) => (value is MethodMirror));
+  Map<Symbol, ClassMirror> _types;
+  Map<Symbol, TypeMirror> get types {
+    if (_types == null) {
+      _types = _filterMap(members, (key, value) => (value is TypeMirror));
     }
-    return _cachedFunctions;
+    return _types;
+  }
+
+  Map<Symbol, ClassMirror> _classes;
+  Map<Symbol, ClassMirror> get classes {
+    if (_classes == null) {
+      _classes = _filterMap(members, (key, value) => (value is ClassMirror));
+    }
+    return _classes;
+  }
+
+  Map<Symbol, MethodMirror> _functions;
+  Map<Symbol, MethodMirror> get functions {
+    if (_functions == null) {
+      _functions = _filterMap(members, (key, value) => (value is MethodMirror));
+    }
+    return _functions;
+  }
+
+  Map<Symbol, MethodMirror> _getters;
+  Map<Symbol, MethodMirror> get getters {
+    if (_getters == null) {
+      _getters = _filterMap(functions, (key, value) => (value.isGetter));
+    }
+    return _getters;
+  }
+
+  Map<Symbol, MethodMirror> _setters;
+  Map<Symbol, MethodMirror> get setters {
+    if (_setters == null) {
+      _setters = _filterMap(functions, (key, value) => (value.isSetter));
+    }
+    return _setters;
+  }
+
+  Map<Symbol, VariableMirror> _variables;
+  Map<Symbol, VariableMirror> get variables {
+    if (_variables == null) {
+      _variables = _filterMap(members,
+                              (key, value) => (value is VariableMirror));
+    }
+    return _variables;
   }
 
   List<InstanceMirror> get metadata {
     // Get the metadata objects, convert them into InstanceMirrors using
     // reflect() and then make them into a Dart list.
     return new UnmodifiableListView(_metadata(_reflectee).map(reflect));
   }
 
   bool operator ==(other) {
     return this.runtimeType == other.runtimeType &&
            this._reflectee == other._reflectee;
   }
 
   int get hashCode => simpleName.hashCode;
 
   String toString() => "LibraryMirror on '${_n(simpleName)}'";
 
   Function operator [](Symbol selector) {
-    var target = _functions[selector];
+    var target = functions[selector];
     if (target == null || !target.isRegularMethod) {
       throw new ArgumentError(
           "${MirrorSystem.getName(simpleName)} has no top-level method "
           "${MirrorSystem.getName(selector)}");
     }
     return new _InvocationTrampoline(this, selector);
   }
 
   _invoke(reflectee, memberName, arguments, argumentNames)
       native 'LibraryMirror_invoke';
@@ skipping 339 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }