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

sdk/lib/mirrors/mirrors.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.
 
 // For the purposes of the mirrors library, we adopt a naming
 // convention with respect to getters and setters.  Specifically, for
 // some variable or field...
 //
 //   var myField;
 //
@@ skipping 94 matching lines @@
    */
   external static String getName(Symbol symbol);
 }
 
 /**
  * Returns a [MirrorSystem] for the current isolate.
  */
 external MirrorSystem currentMirrorSystem();
 
 /**
- * Creates a [MirrorSystem] for the isolate which is listening on
- * the [SendPort].
- */
-external Future<MirrorSystem> mirrorSystemOf(SendPort port);
-
-/**
  * Returns an [InstanceMirror] reflecting [reflectee].
  * If [reflectee] is function or an instance of a class
  * that has a [:call:] method, the returned instance mirror
  * will be a [ClosureMirror].
  *
  * Note that since one cannot obtain an object from
  * another isolate, this function can only be used to
  * obtain  mirrors on objects of the current isolate.
  */
 external InstanceMirror reflect(Object reflectee);
@@ skipping 233 matching lines @@
    * class of *o* (otherwise).
    * If the invocation returns a result *r*, this method returns
    * the result of calling [reflect]([value]).
    * If the invocation causes a compilation error
    * this method throws a [MirroredCompilationError].
    * If the invocation throws an exception *e* (that it does not catch)
    * this method throws *e*.
    */
   /* TODO(turnidge): Handle ambiguous names.*/
   InstanceMirror setField(Symbol fieldName, Object value);
-
-  /**
-   * Invokes the named function and returns a mirror on the result.
-   * The arguments must be instances of [InstanceMirror], or of
-   * a type that is serializable across isolates (currently [num],
-   * [String], or [bool]).
-   *
-   * Let *o* be the object reflected by this mirror, let
-   * *f* be the simple name of the member denoted by [memberName],
-   * let *a1, ..., an* be the elements of [positionalArguments]
-   * let *k1, ..., km* be the identifiers denoted by the elements of
-   * [namedArguments.keys]
-   * and let *v1, ..., vm* be the elements of [namedArguments.values].
-   * For each *ai*, if *ai* is an instance of [InstanceMirror], let *pi*
-   * be the object reflected by *ai*; otherwise let *pi = ai,  i in 1 ...n*.
-   * Likewise, for each *vj*, if *vj* is an instance of [InstanceMirror], let *qj*
-   * be the object reflected by *vj*; otherwise let *qj = vj,  j in 1 ...m*.
-   * If any of the *pi, qj* is not an instance of [InstanceMirror] and
-   * is not serializable across isolates, an exception is thrown.
-   * Then this method will perform the method invocation
-   *  *o.f(p1, ..., pn, k1: q1, ..., km: qm)*
-   * in a scope that has access to the private members
-   * of *o* (if *o* is a class or library) or the private members of the
-   * class of *o*(otherwise).
-   * The method returns a future *k*.
-   * If the invocation returns a result *r*, *k* will be completed
-   * with the result of calling [reflect](*r*).
-   * If the invocation throws an exception *e* (that it does not catch)
-   * then *k* is completed with a [MirrorError] wrapping *e*.
-   */
-  /*
-   * TODO(turnidge): Handle ambiguous names.
-   * TODO(turnidge): Handle optional & named arguments.
-   */
-  Future<InstanceMirror> invokeAsync(Symbol memberName,
-                                     List positionalArguments,
-                                     [Map<Symbol, dynamic> namedArguments]);
-
-  /**
-   * Invokes a getter and returns a mirror on the result. The getter
-   * can be the implicit getter for a field or a user-defined getter
-   * method.
-   *
-   * Let *o* be the object reflected by this mirror, let
-   * *f* be the simple name of the getter denoted by [fieldName],
-   * Then this method will perform the getter invocation
-   *  *o.f*
-   * in a scope that has access to the private members
-   * of *o* (if *o* is a class or library) or the private members of the
-   * class of *o*(otherwise).
-   * The method returns a future *k*.
-   * If the invocation returns a result *r*, *k* will be completed
-   * with the result of calling [reflect](*r*).
-   * If the invocation throws an exception *e* (that it does not catch)
-   * then *k* is completed with a [MirrorError] wrapping *e*.
-   */
-  /* TODO(turnidge): Handle ambiguous names.*/
-  Future<InstanceMirror> getFieldAsync(Symbol fieldName);
-
-  /**
-   * Invokes a setter and returns a mirror on the result. The setter
-   * may be either the implicit setter for a non-final field or a
-   * user-defined setter method.
-   * The second argument must be an instance of [InstanceMirror], or of
-   * a type that is serializable across isolates (currently [num],
-   * [String], or [bool]).
-   *
-   * Let *o* be the object reflected by this mirror, let
-   * *f* be the simple name of the getter denoted by [fieldName],
-   * and let a be the object bound to [value]. If *a* is an instance of
-   * [InstanceMirror]  let *p* be the object
-   * reflected by *a*, otherwise let *p =a*.
-   * If *p* is not an instance of [InstanceMirror], *p* must be
-   * serializable across isolates or an exception is thrown.
-   * Then this method will perform the setter invocation
-   *  *o.f = a*
-   * in a scope that has access to the private members
-   * of *o* (if *o* is a class or library) or the private members of the
-   * class of *o*(otherwise).
-   * The method returns a future *k*.
-   * If the invocation returns a result *r*, *k* will be completed
-   * with the result of calling [reflect](*r*).
-   * If the invocation throws an exception *e* (that it does not catch)
-   * then *k* is completed with a [MirrorError} wrapping *e*.
-   */
-  /* TODO(turnidge): Handle ambiguous names.*/
-  Future<InstanceMirror> setFieldAsync(Symbol fieldName, Object value);
 }
 
 /**
  * An [InstanceMirror] reflects an instance of a Dart language object.
  */
 abstract class InstanceMirror implements ObjectMirror {
   /**
    * A mirror on the type of the reflectee.
    *
    * Returns a mirror on the actual class of the reflectee.
@@ skipping 77 matching lines @@
    * the result of calling [reflect](*r*).
    * If the invocation causes a compilation error
    * this method throws a [MirrorError].
    * If the invocation throws an exception *e* (that it does not catch)
    * this method throws *e*.
    */
   InstanceMirror apply(List positionalArguments,
                        [Map<Symbol, dynamic> namedArguments]);
 
   /**
-   * Executes the closure and returns a mirror on the result.
-   *
-   * Let *f* be the closure reflected by this mirror,
-   * let *a1, ..., an* be the elements of [positionalArguments]
-   * let *k1, ..., km* be the identifiers denoted by the elements of
-   * [namedArguments.keys]
-   * and let *v1, ..., vm* be the elements of [namedArguments.values].
-   * For each *ai*, if *ai* is an instance of [InstanceMirror], let *pi*
-   * be the object reflected by *ai*; otherwise let *pi = ai,  i in 1 ...n*.
-   * Likewise, for each *vj*, if *vj* is an instance of [InstanceMirror], let
-   * *qj*
-   * be the object reflected by *vj*; otherwise let *qj = vj,  j in 1 ...m*.
-   * If any of the *pi, qj* is not an instance of [InstanceMirror] and
-   * is not serializable across isolates, an exception is thrown.
-   * Then this method will perform the function invocation
-   *  *f(p1, ..., pn, k1: q1, ..., km: qm)*
-   * The method returns a future *k*.
-   * If the invocation returns a result *r*, *k* will be completed
-   * with the result of calling [reflect](*r*).
-   * If the invocation throws an exception *e* (that it does not catch)
-   * then *k* is completed with a [MirrorError] wrapping *e*.
-   *
-   * The arguments must be instances of [InstanceMirror], or of
-   * a type that is serializable across isolates (currently [num],
-   * [String], or [bool]).
-   */
-  Future<InstanceMirror> applyAsync(List positionalArguments,
-                                    [Map<Symbol, dynamic> namedArguments]);
-
-  /**

[gbracha, 2013/09/18 22:11:29]

What about newInstanceAsync? It needs to go too.

    * Looks up the value of a name in the scope of the closure. The
    * result is a mirror on that value.
    *
    * Let *s* be the contents of the string used to construct the symbol [name].
    *
    * If the expression *s* occurs within the source code of the reflectee,
    * and that any such occurrence refers to a declaration outside the reflectee,
    * then let *v* be the result of evaluating the expression *s* at such
    * an occurrence.
    * If *s = this*, and the reflectee was defined within the instance scope of
@@ skipping 725 matching lines @@
    *
    * When used as metadata on an import of "dart:mirrors", this metadata does
    * not apply to the library in which the annotation is used, but instead
    * applies to the other libraries (all libraries if "*" is used).
    */
   final override;
 
   const MirrorsUsed(
       {this.symbols, this.targets, this.metaTargets, this.override});
 }