Format all dart: library files

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 199 matching lines @@
 
   /**
    * Whether [other] is an [IsolateMirror] on the same isolate as this mirror.
    *
    * The equality holds if and only if
    *
    * 1. [other] is a mirror of the same kind, and
    * 2. the isolate being reflected by this mirror is the same isolate being
    *    reflected by [other].
    */
-  bool operator == (other);
+  bool operator ==(other);
 }
 
 /**
  * A [DeclarationMirror] reflects some entity declared in a Dart program.
  */
 abstract class DeclarationMirror implements Mirror {
   /**
    * The simple name for this Dart language entity.
    *
    * The simple name is in most cases the identifier name of the entity,
@@ skipping 121 matching lines @@
  * functionality.
  *
  * 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.
    *
    * 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]. 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*\).
    *
    * 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.
    */
-  InstanceMirror invoke(Symbol memberName,
-                        List positionalArguments,
-                        [Map<Symbol,dynamic> namedArguments]);
+  InstanceMirror invoke(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].
    *
@@ skipping 118 matching lines @@
    *
    * 1. [other] is a mirror of the same kind, and
    * 2. either
    *
    *    a. [hasReflectee] is true and so is
    *    [:identical(reflectee, other.reflectee):], or
    *
    *    b. the remote objects reflected by this mirror and by [other] are
    *    identical.
    */
-  bool operator == (other);
+  bool operator ==(other);
 }
 
 /**
  * A [ClosureMirror] reflects a closure.
  *
  * A [ClosureMirror] provides the ability to execute its reflectee and
  * introspect its function.
  */
 abstract class ClosureMirror implements InstanceMirror {
   /**
@@ skipping 32 matching lines @@
    * If the invocation returns a result *r*, this method returns 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]);
+      [Map<Symbol, dynamic> namedArguments]);
 }
 
 /**
  * A [LibraryMirror] reflects a Dart language library, providing
  * access to the variables, functions, and classes of the
  * library.
  */
 abstract class LibraryMirror implements DeclarationMirror, ObjectMirror {
   /**
    * The absolute uri of the library.
@@ skipping 136 matching lines @@
    * A mirror on the original declaration of this type.
    *
    * 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.
    */
   TypeMirror get originalDeclaration;
 
-
   /**
    * Checks the subtype relationship, denoted by `<:` in the language
    * specification.
    *
    * This is the type relationship used in `is` test checks.
    */
   bool isSubtypeOf(TypeMirror other);
 
   /**
    * Checks the assignability relationship, denoted by `<=>` in the language
@@ skipping 61 matching lines @@
    * Returns a map of the static methods, getters and setters of the class.
    *
    * The intent is to capture those members that constitute the API of a class.
    * Hence fields are not included, but the getters and setters implicitly
    * introduced by fields are included.
    *
    * The map is keyed by the simple names of the members.
    */
   Map<Symbol, MethodMirror> get staticMembers;
 
-
   /**
    * The mixin of this class.
    *
    * If this class is the result of a mixin application of the form S with M,
    * returns a class mirror on M. Otherwise returns a class mirror on
    * [reflectee].
    */
   ClassMirror get mixin;
 
   // TODO(ahe): What about:
@@ skipping 22 matching lines @@
    *
    * In either case:
    *
    * * If the expression evaluates to a result *r*, this method returns 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]);
+  InstanceMirror newInstance(Symbol constructorName, List positionalArguments,
+      [Map<Symbol, dynamic> namedArguments]);
 
   /**
    * Whether this mirror is equal to [other].
    *
    * 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 a generic class, 2.
    * implies that the reflected class and [other] have equal type arguments.
    */
-  bool operator == (other);
+  bool operator ==(other);
 
   /**
    * Returns whether the class denoted by the receiver is a subclass of the
    * class denoted by the argument.
    *
    * Note that the subclass relationship is reflexive.
    */
   bool isSubclassOf(ClassMirror other);
 }
 
@@ skipping 39 matching lines @@
 
   /**
    * Whether [other] is a [TypeVariableMirror] on the same type variable as this
    * mirror.
    *
    * The equality holds if and only if
    *
    * 1. [other] is a mirror of the same kind, and
    * 2. [:simpleName == other.simpleName:] and [:owner == other.owner:].
    */
-  bool operator == (other);
+  bool operator ==(other);
 }
 
 /**
  * A [TypedefMirror] represents a typedef in a Dart language program.
  */
 abstract class TypedefMirror implements TypeMirror {
   /**
    * The defining type for this typedef.
    *
    * If the type referred to by the reflectee is a function type *F*, the
@@ skipping 107 matching lines @@
   bool get isFactoryConstructor;
 
   /**
    * Whether this mirror is equal to [other].
    *
    * The equality holds if and only if
    *
    * 1. [other] is a mirror of the same kind, and
    * 2. [:simpleName == other.simpleName:] and [:owner == other.owner:].
    */
-  bool operator == (other);
+  bool operator ==(other);
 }
 
 /**
  * A [VariableMirror] reflects a Dart language variable declaration.
  */
 abstract class VariableMirror implements DeclarationMirror {
   /**
    * Returns a mirror on the type of the reflectee.
    */
   TypeMirror get type;
@@ skipping 20 matching lines @@
   bool get isConst;
 
   /**
    * Whether this mirror is equal to [other].
    *
    * The equality holds if and only if
    *
    * 1. [other] is a mirror of the same kind, and
    * 2. [:simpleName == other.simpleName:] and [:owner == other.owner:].
    */
-  bool operator == (other);
+  bool operator ==(other);
 }
 
 /**
  * A [ParameterMirror] reflects a Dart formal parameter declaration.
  */
 abstract class ParameterMirror implements VariableMirror {
   /**
    * A mirror on the type of this parameter.
    */
   TypeMirror get type;
@@ skipping 324 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});
 }