Mirror removals: async invoke, mirrorSystemOf(port), Mirror.mirrors.

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";
 
 // These values are allowed to be passed directly over the wire.
 bool _isSimpleValue(var value) {
@@ skipping 58 matching lines @@
     buf.write(']');
   }
   buf.write(') -> ');
   buf.write(_n(returnType.qualifiedName));
   return buf.toString();
 }
 
 List _metadata(reflectee)
   native 'DeclarationMirror_metadata';
 
-// This will verify the argument types, unwrap them, and ensure we have a fixed
-// array.
-List _unwrapAsyncPositionals(wrappedArgs) {
-  List unwrappedArgs = new List(wrappedArgs.length);
-  for(int i = 0; i < wrappedArgs.length; i++){
-    var wrappedArg = wrappedArgs[i];
-    if(_isSimpleValue(wrappedArg)) {
-      unwrappedArgs[i] = wrappedArg;
-    } else if(wrappedArg is InstanceMirror) {
-      unwrappedArgs[i] = wrappedArg._reflectee;
-    } else {
-      throw "positional argument $i ($wrappedArg) was "
-            "not a simple value or InstanceMirror";
-    }
-  }
-  return unwrappedArgs;
-}
-
-Map _unwrapAsyncNamed(wrappedArgs) {
-  if (wrappedArgs==null) return null;
-  Map unwrappedArgs = new Map();
-  wrappedArgs.forEach((name, wrappedArg){
-    if(_isSimpleValue(wrappedArg)) {
-      unwrappedArgs[name] = wrappedArg;
-    } else if(wrappedArg is InstanceMirror) {
-      unwrappedArgs[name] = wrappedArg._reflectee;
-    } else {
-      throw "named argument ${_n(name)} ($wrappedArg) was "
-            "not a simple value or InstanceMirror";
-    }
-  });
-  return unwrappedArgs;
-}
-
 class _LocalMirrorSystemImpl extends MirrorSystem {
   // Change parameter back to "this.libraries" when native code is changed.
   _LocalMirrorSystemImpl(List<LibraryMirror> libraries, this.isolate)
       : this.libraries = new Map<Uri, LibraryMirror>.fromIterable(
             libraries, key: (e) => e.uri);
 
   final Map<Uri, LibraryMirror> libraries;
   final IsolateMirror isolate;
 
   TypeMirror _dynamicType = null;
   TypeMirror get dynamicType {
     if (_dynamicType == null) {
       _dynamicType = new _SpecialTypeMirrorImpl('dynamic');
     }
     return _dynamicType;
   }
 
   TypeMirror _voidType = null;
   TypeMirror get voidType {
     if (_voidType == null) {
       _voidType = new _SpecialTypeMirrorImpl('void');
     }
     return _voidType;
   }
 
   String toString() => "MirrorSystem for isolate '${isolate.debugName}'";
 }
 
 abstract class _LocalMirrorImpl implements Mirror {
-  int get hashCode {
-    throw new UnimplementedError('Mirror.hashCode is not implemented');
-  }
-
-  // Local mirrors always return the same MirrorSystem.  This field
-  // is more interesting once we implement remote mirrors.
-  MirrorSystem get mirrors => _Mirrors.currentMirrorSystem();
 }
 
 class _LocalIsolateMirrorImpl extends _LocalMirrorImpl
     implements IsolateMirror {
   _LocalIsolateMirrorImpl(this.debugName, this.rootLibrary);
 
   final String debugName;
   final bool isCurrent = true;
   final LibraryMirror rootLibrary;
 
@@ skipping 36 matching lines @@
                                       _n(memberName))); 
   }
 
   InstanceMirror setField(Symbol memberName, Object value) {
     this._invokeSetter(_reflectee,
                        _n(memberName),
                        value);
     return reflect(value);
   }
 
-  Future<InstanceMirror> invokeAsync(Symbol memberName,
-                                     List positionalArguments,
-                                     [Map<Symbol, dynamic> namedArguments]) {
-    return new Future(() {
-      return this.invoke(memberName,
-                         _unwrapAsyncPositionals(positionalArguments),
-                         _unwrapAsyncNamed(namedArguments));
-    });
-  }
-
-  Future<InstanceMirror> getFieldAsync(Symbol memberName) {
-   try {
-      var result = this._invokeGetter(_reflectee,
-                                      _n(memberName));
-      return new Future.value(reflect(result)); 
-    } catch(e) {
-      return new Future.error(e);
-    }
-  }
-
-  Future<InstanceMirror> setFieldAsync(Symbol memberName, Object value) {
-    try {
-      var unwrappedValue;
-      if(_isSimpleValue(value)) {
-        unwrappedValue = value;
-      } else if(value is InstanceMirror) {
-        unwrappedValue = value._reflectee;
-      } else { 
-        throw "setter argument ($value) must be"
-              "a simple value or InstanceMirror";
-      }
-
-      this._invokeSetter(_reflectee,
-                         _n(memberName),
-                         unwrappedValue);
-      return new Future.value(reflect(unwrappedValue)); 
-    } catch(e) {
-      return new Future.error(e);
-    }
-  }
-
   static _validateArgument(int i, Object arg)
   {
     if (arg is Mirror) {
         if (arg is! InstanceMirror) {
           throw new MirrorException(
               'positional argument $i ($arg) was not an InstanceMirror');
         }
       } else if (!_isSimpleValue(arg)) {
         throw new MirrorException(
             'positional argument $i ($arg) was not a simple value');
@@ skipping 214 matching lines @@
   }
 
   bool get isPrivate => _n(simpleName).startsWith('_');
 
   final bool isTopLevel = true;
 
   SourceLocation get location {
     throw new UnimplementedError('ClassMirror.location is not implemented');
   }
 
-  // TODO(rmacnak): Remove these left-overs from the days of separate interfaces
-  // once we send out a breaking change.
-  bool get isClass => true;
-  ClassMirror get defaultFactory => null;
-
   ClassMirror _trueSuperclassField;
   ClassMirror get _trueSuperclass {
     if (_trueSuperclassField == null) {
       Type supertype = _supertype(_reflectee);
       if (supertype == null) {
         // Object has no superclass.
         return null;
       }
       _trueSuperclassField = _Mirrors._reflectType(supertype);
     }
@@ skipping 775 matching lines @@
       native 'Mirrors_makeLocalMirrorSystem';
 
   // The MirrorSystem for the current isolate.
   static MirrorSystem currentMirrorSystem() {
     if (_currentMirrorSystem == null) {
       _currentMirrorSystem = makeLocalMirrorSystem();
     }
     return _currentMirrorSystem;
   }
 
-  static Future<MirrorSystem> mirrorSystemOf(SendPort port) {
-    if (isLocalPort(port)) {
-      // Make a local mirror system.
-      try {
-        return new Future<MirrorSystem>.value(currentMirrorSystem());
-      } catch (exception) {
-        return new Future<MirrorSystem>.error(exception);
-      }
-    } else {
-      // Make a remote mirror system
-      throw new UnimplementedError(
-          'Remote mirror support is not implemented');
-    }
-  }
-
   // Creates a new local mirror for some Object.
   static InstanceMirror reflect(Object reflectee) {
     return reflectee is Function 
         ? new _LocalClosureMirrorImpl(reflectee)
         : new _LocalInstanceMirrorImpl(reflectee);
   }
 
   static ClassMirror makeLocalClassMirror(Type key)
       native "Mirrors_makeLocalClassMirror";
   static TypeMirror makeLocalTypeMirror(Type key)
@@ skipping 19 matching lines @@
     if (typeMirror == null) {
       typeMirror = makeLocalTypeMirror(key);
       _instanitationCache[key] = typeMirror;
       if (typeMirror is ClassMirror && !typeMirror._isGeneric) {
         _declarationCache[key] = typeMirror;
       }
     }
     return typeMirror;
   }
 }