pkg/smoke: support latest analyzer version and formatted code

lib/smoke.dart

 // Copyright (c) 2014, 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.
 
 /// Collects services that can be used to access objects dynamically, inspect
 /// type information, and convert between symbols and strings.
 library smoke;
 
 import 'src/implementation.dart' as implementation;
 
@@ skipping 21 matching lines @@
 /// Update the [value] of [field] in [object].
 void write(Object object, Symbol field, value) =>
     implementation.objectAccessor.write(object, field, value);
 
 /// Invoke [method] in [receiver] with [args]. The [receiver] can be either an
 /// object (to invoke instance methods) or a type (to invoke static methods).
 /// This function optionally [adjust]s the list of arguments to match the number
 /// of formal parameters by either adding nulls for missing arguments, or by
 /// truncating the list.
 invoke(receiver, Symbol method, List args,
-    {Map namedArgs, bool adjust: false}) =>
-    implementation.objectAccessor.invoke(
-        receiver, method, args, namedArgs: namedArgs, adjust: adjust);
+    {Map namedArgs, bool adjust: false}) => implementation.objectAccessor
+    .invoke(receiver, method, args, namedArgs: namedArgs, adjust: adjust);
 
 /// Tells whether [type] is transitively a subclass of [supertype].
 bool isSubclassOf(Type type, Type supertype) =>
     implementation.typeInspector.isSubclassOf(type, supertype);
 
 // TODO(sigmund): consider adding also:
 // * isImplementationOf(type, subtype) to tells whether [type] declares that it
 //   implements the [supertype] interface.
 // * isSubtypeOf(type, subtype): Tells whether [type]'s interface is a sybtype
 //   of [supertype]. That is, whether it is a subclass or if [type] implements
@@ skipping 64 matching lines @@
 
   /// If [withAnnotation] is not null, then it should be a list of types, so
   /// only symbols that are annotated with instances of those types are
   /// included.
   final List withAnnotations;
 
   /// If [matches] is not null, then include only those fields, properties, or
   /// methods that match the predicate.
   final NameMatcher matches;
 
-  const QueryOptions({
-      this.includeFields: true,
-      this.includeProperties: true,
-      this.includeInherited: true,
-      this.includeUpTo: Object,
-      this.excludeFinal: false,
-      this.includeMethods: false,
-      this.withAnnotations: null,
-      this.matches: null});
+  const QueryOptions({this.includeFields: true, this.includeProperties: true,
+      this.includeInherited: true, this.includeUpTo: Object,
+      this.excludeFinal: false, this.includeMethods: false,
+      this.withAnnotations: null, this.matches: null});
 
   String toString() => (new StringBuffer()
-      ..write('(options:')
-      ..write(includeFields ? 'fields ' : '')
-      ..write(includeProperties ? 'properties ' : '')
-      ..write(includeMethods ? 'methods ' : '')
-      ..write(includeInherited ? 'inherited ' : '_')
-      ..write(excludeFinal ? 'no finals ' : '')
-      ..write('annotations: $withAnnotations')
-      ..write(matches != null ? 'with matcher' : '')
-      ..write(')')).toString();
+    ..write('(options:')
+    ..write(includeFields ? 'fields ' : '')
+    ..write(includeProperties ? 'properties ' : '')
+    ..write(includeMethods ? 'methods ' : '')
+    ..write(includeInherited ? 'inherited ' : '_')
+    ..write(excludeFinal ? 'no finals ' : '')
+    ..write('annotations: $withAnnotations')
+    ..write(matches != null ? 'with matcher' : '')
+    ..write(')')).toString();
 }
 
 /// Used to filter query results based on a predicate on [name]. Returns true if
 /// [name] should be included in the query results.
 typedef bool NameMatcher(Symbol name);
 
 /// Information associated with a symbol declaration (like a property or
 /// method).
 class Declaration {
   /// Name of the property or method
@@ skipping 22 matching lines @@
   /// Whether this symbol is static.
   final bool isStatic;
 
   /// List of annotations in this declaration.
   final List annotations;
 
   const Declaration(this.name, this.type, {this.kind: FIELD,
       this.isFinal: false, this.isStatic: false, this.annotations: const []});
 
   int get hashCode => name.hashCode;
-  operator ==(other) => other is Declaration && name == other.name &&
-      kind == other.kind && isFinal == other.isFinal &&
-      type == other.type && isStatic == other.isStatic &&
+  operator ==(other) => other is Declaration &&
+      name == other.name &&
+      kind == other.kind &&
+      isFinal == other.isFinal &&
+      type == other.type &&
+      isStatic == other.isStatic &&
       compareLists(annotations, other.annotations);
 
   String toString() {
     return (new StringBuffer()
-        ..write('(declaration ')
-        ..write(name)
-        ..write(isProperty ? ' (property) ' : ' (method) ')
-        ..write(isFinal ? 'final ' : '')
-        ..write(isStatic ? 'static ' : '')
-        ..write(annotations)
-        ..write(')')).toString();
+      ..write('(declaration ')
+      ..write(name)
+      ..write(isProperty ? ' (property) ' : ' (method) ')
+      ..write(isFinal ? 'final ' : '')
+      ..write(isStatic ? 'static ' : '')
+      ..write(annotations)
+      ..write(')')).toString();
   }
 }
 
 /// Enumeration for declaration kinds (field, property, or method)
 class DeclarationKind {
   final int kind;
   const DeclarationKind(this.kind);
 }
 
 /// Declaration kind used to denote a raw field.
 const FIELD = const DeclarationKind(0);
 
 /// Declaration kind used to denote a getter/setter.
 const PROPERTY = const DeclarationKind(1);
 
 /// Declaration kind used to denote a method.
 const METHOD = const DeclarationKind(2);
 
-
 /// A service that provides a way to implement simple operations on objects like
 /// read, write, and invoke.
 abstract class ObjectAccessorService {
   /// Return the value of [field] in [object].
   read(Object object, Symbol field);
 
   /// Update the [value] of [field] in [object].
   void write(Object object, Symbol field, value);
 
   /// Invoke [method] in [object] with [args]. It optionally [adjust]s the list
   /// of arguments to match the number of formal parameters by either adding
   /// nulls for missing arguments, or by truncating the list.
   invoke(Object object, Symbol method, List args,
       {Map namedArgs, bool adjust: false});
 }
 
-
 /// A service that provides partial inspection into Dart types.
 abstract class TypeInspectorService {
   /// Tells whether [type] is transitively a subclass of [supertype].
   bool isSubclassOf(Type type, Type supertype);
 
   /// Tells whether [type] has a field or getter for [name].
   bool hasGetter(Type type, Symbol name);
 
   /// Tells whether [type] has a field or setter for [name].
   bool hasSetter(Type type, Symbol name);
 
   /// Tells whether [type] has a specific instance [method].
   bool hasInstanceMethod(Type type, Symbol method);
 
   /// Tells whether [type] has a specific static [method].
   bool hasStaticMethod(Type type, Symbol method);
 
   /// Get the declaration associated with field [name] in [type].
   Declaration getDeclaration(Type type, Symbol name);
 
   /// Retrieve all symbols of [type] that match [options].
   List<Declaration> query(Type type, QueryOptions options);
 }
 
-
-/// A service that converts between [Symbol]s and [String]s. 
+/// A service that converts between [Symbol]s and [String]s.
 abstract class SymbolConverterService {
   /// Returns the name associated with a [symbol].
   String symbolToName(Symbol symbol);
 
   /// Returns the symbol associated with a [name].
   Symbol nameToSymbol(String name);
 }