EAKING CHANGE: Rename InstanceMIrror.invoke, .getField, .setField to invokeAsync, getFieldAsync, se…

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 156 matching lines @@
  * For the purposes of the mirrors library, these types are all
  * object-like, in that they support method invocation and field
  * access.  Real Dart objects are represented by the [InstanceMirror]
  * type.
  *
  * See [InstanceMirror], [ClassMirror], and [LibraryMirror].
  */
 abstract class ObjectMirror implements Mirror {
   /**
    * Invokes the named function and returns a mirror on the result.
+   * The arguments must be InstanceMirrors, numbers, strings 
+   * or booleans.

[ahe, 2013/04/10 05:52:22]

[InstanceMirror], [num], [String], or [bool].

    *
    * TODO(turnidge): Properly document.
    * TODO(turnidge): Handle ambiguous names.
    * TODO(turnidge): Handle optional & named arguments.

[ahe, 2013/04/10 05:52:22]

Remove TODO from documentation, it should just be plain comments.

[gbracha, 2013/04/10 18:01:16]

I will do this for method affected by this CL.  There are other such cases which
should also change, but others have expressed a desire that the CL focus on  one
main purpose, so the others can be changed later.

    */
-  Future<InstanceMirror> invoke(String memberName,
-                                List<Object> positionalArguments,
-                                [Map<String,Object> namedArguments]);
+  Future<InstanceMirror> invokeAsync(String memberName,
+                                     List<Object> positionalArguments,
+                                     [Map<String,Object> 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.
    *
    * TODO(turnidge): Handle ambiguous names.
    */
-  Future<InstanceMirror> getField(String fieldName);
+  Future<InstanceMirror> getFieldAsync(String 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 argument must be either an InstanceMirror, a number, a string 
+   * or a boolean.
    *
    * TODO(turnidge): Handle ambiguous names.
    */
-  Future<InstanceMirror> setField(String fieldName, Object value);
+  Future<InstanceMirror> setFieldAsync(String 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.
    */
   ClassMirror get type;
@@ skipping 45 matching lines @@
   /**
    * Executes the closure. The arguments given in the descriptor need to
    * be InstanceMirrors or simple values.
    *
    * A value is simple if one of the following holds:
    *  - the value is null
    *  - the value is of type [num]
    *  - the value is of type [bool]
    *  - the value is of type [String]
    */
-  Future<InstanceMirror> apply(List<Object> positionalArguments,
-                               [Map<String,Object> namedArguments]);
+  Future<InstanceMirror> applyAsync(List<Object> positionalArguments,
+                                    [Map<String,Object> namedArguments]);
 
   /**
    * Looks up the value of a name in the scope of the closure. The
    * result is a mirror on that value.
    */
   Future<InstanceMirror> findInContext(String name);
 }
 
 /**
  * A [LibraryMirror] reflects a Dart language library, providing
@@ skipping 149 matching lines @@
    * For most classes, they are their own original declaration.  For
    * generic classes, however, there is a distinction between the
    * original class declaration, which has unbound type variables, and
    * the instantiations of generic classes, which have bound type
    * variables.
    */
   ClassMirror get originalDeclaration;
 
   /**
    * Invokes the named constructor and returns a mirror on the result.
+   * The arguments must be InstanceMirrors, numbers, strings 
+   * or booleans.
    *
    * TODO(turnidge): Properly document.
    */
-  Future<InstanceMirror> newInstance(String constructorName,
-                                     List<Object> positionalArguments,
-                                     [Map<String,Object> namedArguments]);
+  Future<InstanceMirror> newInstanceAsync(String constructorName,
+                                          List<Object> positionalArguments,
+                                          [Map<String,Object> namedArguments]);
 
   /**
    * Does this mirror represent a class?
    *
    * TODO(turnidge): This functions goes away after the
    * class/interface changes.
    */
   bool get isClass;
 
   /**
@@ skipping 304 matching lines @@
   /**
    * Is [:true:] if this comment is a documentation comment.
    *
    * That is, that the comment is either enclosed in [: /** ... */ :] or starts
    * with [: /// :].
    */
   final bool isDocComment;
 
   const Comment(this.text, this.trimmedText, this.isDocComment);
 }