pkg/smoke: support latest analyzer version and formatted code

lib/mirrors.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.
 
 /// Implementation of the smoke services using mirrors.
 library smoke.mirrors;
 
 import 'dart:mirrors';
 import 'package:smoke/smoke.dart';
 import 'package:logging/logging.dart';
 import 'src/common.dart';
 
 /// Set up the smoke package to use a mirror-based implementation. To tune what
 /// is preserved by `dart:mirrors`, use a @MirrorsUsed annotation and include
 /// 'smoke.mirrors' in your override arguments.
 useMirrors() {
   configure(new ReflectiveObjectAccessorService(),
       new ReflectiveTypeInspectorService(),
       new ReflectiveSymbolConverterService());
 }
 
 var _logger = new Logger('smoke.mirrors');
 
-
 /// Implements [ObjectAccessorService] using mirrors.
 class ReflectiveObjectAccessorService implements ObjectAccessorService {
   read(Object object, Symbol name) => reflect(object).getField(name).reflectee;
 
   void write(Object object, Symbol name, value) {
     reflect(object).setField(name, value);
   }
 
   invoke(receiver, Symbol methodName, List args,
       {Map namedArgs, bool adjust: false}) {
@@ skipping 100 matching lines @@
     return new _MirrorDeclaration(mirror, declaration);
   }
 
   List<Declaration> query(Type type, QueryOptions options) {
     var mirror = reflectType(type);
     if (mirror is! ClassMirror) return null;
     return _query(mirror, options);
   }
 
   List<Declaration> _query(ClassMirror cls, QueryOptions options) {
-    final visitParent = options.includeInherited && cls.superclass != null && 
+    final visitParent = options.includeInherited && cls.superclass != null &&
         // TODO(sigmund): use _toType(cls.superclass) != options.includeUpTo
         // when dartbug.com/16925 gets fixed (_toType fails in dart2js if
         // applied to classes with type-arguments).
         cls.superclass != reflectClass(options.includeUpTo);
     var result = visitParent ? _query(cls.superclass, options) : [];
     for (var member in cls.declarations.values) {
       if (member is! VariableMirror && member is! MethodMirror) continue;
       if (member.isStatic || member.isPrivate) continue;
       var name = member.simpleName;
       if (member is VariableMirror) {
         if (!options.includeFields) continue;
         if (options.excludeFinal && member.isFinal) continue;
       }
 
       // TODO(sigmund): what if we have a setter but no getter?
       if (member is MethodMirror && member.isSetter) continue;
       if (member is MethodMirror && member.isConstructor) continue;
 
       if (member is MethodMirror && member.isGetter) {
         if (!options.includeProperties) continue;
         if (options.excludeFinal && !_hasSetter(cls, member)) continue;
       }
 
       if (member is MethodMirror && member.isRegularMethod) {
         if (!options.includeMethods) continue;
       }
 
       if (options.matches != null && !options.matches(name)) continue;
 
-      var annotations =
-          member.metadata.map((m) => m.reflectee).toList();
+      var annotations = member.metadata.map((m) => m.reflectee).toList();
       if (options.withAnnotations != null &&
           !matchesAnnotation(annotations, options.withAnnotations)) {
         continue;
       }
 
       // TODO(sigmund): should we cache parts of this declaration so we don't
       // compute them twice?  For example, this chould be `new Declaration(name,
       // type, ...)` and we could reuse what we computed above to implement the
       // query filtering.  Note, when I tried to eagerly compute everything, I
       // run into trouble with type (`type = _toType(member.type)`), dart2js
       // failed when the underlying types had type-arguments (see
       // dartbug.com/16925).
       result.add(new _MirrorDeclaration(cls, member));
     }
 
     return result;
   }
 }
 
 /// Implements [SymbolConverterService] using mirrors.
 class ReflectiveSymbolConverterService implements SymbolConverterService {
   String symbolToName(Symbol symbol) => MirrorSystem.getName(symbol);
   Symbol nameToSymbol(String name) => new Symbol(name);
 }
 
-
 // TODO(jmesserly): workaround for:
 // https://code.google.com/p/dart/issues/detail?id=10029
 Symbol _setterName(Symbol getter) =>
     new Symbol('${MirrorSystem.getName(getter)}=');
 
-
 ClassMirror _safeSuperclass(ClassMirror type) {
   try {
     var t = type.superclass;
     // TODO(sigmund): workaround for darbug.com/17779.
     // Interceptor is leaked by dart2js. It has the same methods as Object
     // (including noSuchMethod), and our code above assumes that it doesn't
     // exist. Most queries exclude Object, so they should exclude Interceptor
     // too. We don't check for t.simpleName == #Interceptor because depending on
     // dart2js optimizations it may be #Interceptor or #num/Interceptor.
     // Checking for a private library seems to reliably filter this out.
@@ skipping 54 matching lines @@
 
   bool get isField => _original is VariableMirror;
 
   bool get isProperty =>
       _original is MethodMirror && !_original.isRegularMethod;
 
   bool get isMethod => !isField && !isProperty;
 
   /// If this is a property, whether it's read only (final fields or properties
   /// with no setter).
-  bool get isFinal =>
-      (_original is VariableMirror && _original.isFinal) ||
-      (_original is MethodMirror && _original.isGetter &&
-           !_hasSetter(_cls, _original));
+  bool get isFinal => (_original is VariableMirror && _original.isFinal) ||
+      (_original is MethodMirror &&
+          _original.isGetter &&
+          !_hasSetter(_cls, _original));
 
   /// If this is a property, it's declared type (including dynamic if it's not
   /// declared). For methods, the returned type.
   Type get type {
     if (_original is MethodMirror && _original.isRegularMethod) {
       return Function;
     }
-    var typeMirror = _original is VariableMirror ? _original.type
-        : _original.returnType;
+    var typeMirror =
+        _original is VariableMirror ? _original.type : _original.returnType;
     return _toType(typeMirror);
   }
 
   /// Whether this symbol is static.
   bool get isStatic => _original.isStatic;
 
   /// List of annotations in this declaration.
   List get annotations => _original.metadata.map((a) => a.reflectee).toList();
 
   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() => (new StringBuffer()
-      ..write('(mirror-based-declaration ')
-      ..write(name)
-      ..write(isField ? ' (field) '
-          : (isProperty ? ' (property) ' : ' (method) '))
-      ..write(isFinal ? 'final ' : '')
-      ..write(isStatic ? 'static ' : '')
-      ..write(annotations)
-      ..write(')')).toString();
+    ..write('(mirror-based-declaration ')
+    ..write(name)
+    ..write(
+        isField ? ' (field) ' : (isProperty ? ' (property) ' : ' (method) '))
+    ..write(isFinal ? 'final ' : '')
+    ..write(isStatic ? 'static ' : '')
+    ..write(annotations)
+    ..write(')')).toString();
 }