Fix some markup in the mirrors docs.

sdk/lib/mirrors/mirrors.dart

 // Copyright (c) 2013, 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 353 matching lines @@
    * 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].
    * Then this method will perform the method invocation
    *  *o.f(a1, ..., an, k1: v1, ..., km: vm)*
    * 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 the invocation returns a result *r*, this method returns
-   * the result of calling [reflect](*r*).
+   * the result of calling [reflect]\(*r*\).
    * 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.
    * TODO(turnidge): Handle optional & named arguments.
    */
@@ skipping 20 matching lines @@
    *
    * 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.
    *
    * If the invocation returns a result *r*, this method returns
-   * the result of calling [reflect](*r*).
+   * the result of calling [reflect]\(*r*\).
    * 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(ahe): Remove stuff about scope and private members. [fieldName] is a
   // capability giving access to private members.
   InstanceMirror getField(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.
    *
    * 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].
    * 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).
    * If the invocation returns a result *r*, this method returns
-   * the result of calling [reflect]([value]).
+   * 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);
 }
 
@@ skipping 47 matching lines @@
    * (b) the remote objects reflected by this mirror and
    * by [other] are identical.
    */
   bool operator == (other);
 
   /**
    * Perform [invocation] on [reflectee].
    * Equivalent to
    *
    *     if (invocation.isGetter) {
-   *        return this.getField(invocation.memberName).reflectee;
+   *       return this.getField(invocation.memberName).reflectee;
    *     } else if (invocation.isSetter) {
    *       return this.setField(invocation.memberName,
    *                            invocation.positionArguments[0]).reflectee;
    *     } else {
    *       return this.invoke(invocation.memberName,
    *                          invocation.positionalArguments,
    *                          invocation.namedArguments).reflectee;
    *     }
    */
   delegate(Invocation invocation);
@@ skipping 30 matching lines @@
   /**
    * 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].
    * Then this method will perform the method invocation
    *  *f(a1, ..., an, k1: v1, ..., km: vm)*
    * If the invocation returns a result *r*, this method returns
-   * the result of calling [reflect](*r*).
+   * the result of calling [reflect]\(*r*\).
    * 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*.
    */
   InstanceMirror apply(List positionalArguments,
                        [Map<Symbol, dynamic> namedArguments]);
 }
 
@@ skipping 260 matching lines @@
    * *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:
    * If the expression evaluates to a result *r*, this method returns
-   * the result of calling [reflect](*r*).
+   * the result of calling [reflect]\(*r*\).
    * If evaluating the expression causes a compilation error
    * 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]);
@@ skipping 579 matching lines @@
   final override;
 
   /**
    * See the documentation for [MirrorsUsed.symbols], [MirrorsUsed.targets], 
    * [MirrorsUsed.metaTargets] and [MirrorsUsed.override] for documentation 
    * of the parameters.
    */
   const MirrorsUsed(
       {this.symbols, this.targets, this.metaTargets, this.override});
 }