Mirror API removals: async invocations, 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 107 matching lines @@
    */
   external static Symbol getSymbol(String name, [LibraryMirror library]);
 }
 
 /**
  * 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);
-
-/**
  * Reflects an instance.
  * Returns an [InstanceMirror] reflecting [reflectee].
  * If [reflectee] is a 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.
  */
@@ skipping 26 matching lines @@
  * another isolate, this function can only be used to
  * obtain type mirrors on types of the current isolate.
  */
 external TypeMirror reflectType(Type key);
 
 /**
  * A [Mirror] reflects some Dart language entity.
  *
  * Every [Mirror] originates from some [MirrorSystem].
  */
-abstract class Mirror {
-  /**
-   * The [MirrorSystem] that contains this mirror.
-   */
-  MirrorSystem get mirrors;
-}
+abstract class Mirror {}
 
 /**
  * An [IsolateMirror] reflects an isolate.
  */
 abstract class IsolateMirror implements Mirror {
   /**
    * Returns a unique name used to refer to an isolate
    * in debugging messages.
    */
   String get debugName;
@@ skipping 216 matching lines @@
    * If the invocation returns a result *r*, this method returns
    * the result of calling [reflect]([value]).
    * If the invocation causes a compilation error
    * the effect is the same as if a non-reflective compilation error 
    * had been encountered.
    * 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).
-   *
-   * If this mirror is an [InstanceMirror], and [fieldName] denotes an instance
-   * method on its reflectee, the result of the invocation is an instance
-   * mirror on a closure corresponding to that method.
-   *
-   * If this mirror is a [LibraryMirror], and [fieldName] denotes a top-level
-   * method in the corresponding library, the result of the invocation is an
-   * instance mirror on a closure corresponding to that method.
-   *
-   * If this mirror is a [ClassMirror], and [fieldName] denotes a static method
-   * in the corresponding class, the result of the invocation is an instance
-   * mirror on a closure corresponding to that method.
-   *
-   * 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]);
-
-  /**
    * 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 if 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 255 matching lines @@
    * the effect is the same as if a non-reflective compilation error 
    * had been encountered.
    * If evaluating the expression throws an exception *e*
    * (that it does not catch)
    * this method throws *e*.
    */
   InstanceMirror newInstance(Symbol constructorName,
                              List positionalArguments,
                              [Map<Symbol,dynamic> namedArguments]);
 
- /**
-   * 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 *c* be the class 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.
-   * If [constructorName] was created from the empty string
-   * Then this method will execute the instance creation expression
-   * *new c(a1, ..., an, k1: v1, ..., km: vm)*
-   * in a scope that has access to the private members
-   * of *c*. Otherwise, let
-   * *f* be the simple name of the constructor denoted by [constructorName]
-   * Then this method will execute the instance creation expression
-   *  *new c.f(a1, ..., an, k1: v1, ..., km: vm)*
-   * in a scope that has access to the private members
-   * of *c*.
-   * In either case:
-   * 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*.
-*/
-  Future<InstanceMirror> newInstanceAsync(Symbol constructorName,
-                                          List positionalArguments,
-                                          [Map<Symbol, dynamic> namedArguments]);
-
   /**
    * Returns [:true:] if this mirror is equal to [other].
    * Otherwise returns [:false:].
    *
    * The equality holds if and only if
    * (1) [other] is a mirror of the same kind
    * and
    * (2) This mirror and [other] reflect the same class.
    *
    * Note that if the reflected class is an invocation of
@@ skipping 449 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});
 }