Adapting observe to use smoke (this is built on top of the previous change that

pkg/smoke/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';
@@ skipping 127 matching lines @@
 
   List<Declaration> _query(ClassMirror cls, QueryOptions options) {
     var result = (!options.includeInherited || cls.superclass == _objectType)
         ? [] : _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;
       bool isMethod = false;
       if (member is VariableMirror) {
-        if (!options.includeProperties) continue;
+        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;
@@ skipping 82 matching lines @@
 }
 
 class _MirrorDeclaration implements Declaration {
   final ClassMirror _cls;
   final _original;
 
   _MirrorDeclaration(this._cls, DeclarationMirror this._original);
 
   Symbol get name => _original.simpleName;
 
-  /// Whether the symbol is a property (either this or [isMethod] is true).
-  bool get isProperty => _original is VariableMirror ||
-      (_original is MethodMirror && !_original.isRegularMethod);
+  bool get isField => _original is VariableMirror;
 
-  /// Whether the symbol is a method (either this or [isProperty] is true)
-  bool get isMethod => !isProperty;
+  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));
 
   /// 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;
     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();
 
   String toString() {
     return (new StringBuffer()
         ..write('[declaration ')
         ..write(name)
-        ..write(isProperty ? ' (property) ' : ' (method) ')
+        ..write(isField ? ' (field) '
+            : (isProperty ? ' (property) ' : ' (method) '))
         ..write(isFinal ? 'final ' : '')
         ..write(isStatic ? 'static ' : '')
         ..write(annotations)
         ..write(']')).toString();
   }
 }
 
 class _MethodClosure extends Function {
   final receiver;
   final Symbol methodName;
 
   _MethodClosure(this.receiver, this.methodName);
 
   // We shouldn't need to include [call] here, but we do to work around an
   // analyzer bug (see dartbug.com/16078). Interestingly, if [call] is invoked
   // with the wrong number of arguments, then noSuchMethod is anyways invoked
   // instead.
   call() => invoke(receiver, methodName, const []);
 
   noSuchMethod(Invocation inv) {
     if (inv.memberName != #call) return null;
     return invoke(receiver, methodName,
         inv.positionalArguments, namedArgs: inv.namedArguments);
   }
 }