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);
+  DeclarationKind get kind => isField ? FIELD : isProperty ? PROPERTY : METHOD;
 
-  /// Whether the symbol is a method (either this or [isProperty] is true)
-  bool get isMethod => !isProperty;
+  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));
 
   /// 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);
 
   // Technically we could just use noSuchMethod to implement [call], but we
   // don't for 3 reasons:
   //   * noSuchMethod makes the code a lot bigger.
   //   * even with noSuchMethod, an analyzer bug requires to declare [call] (see
   //     dartbug.com/16078).
   //   * having [call] also allows `is` checks to work for functions of 0
   //     through 3 arguments.  We depend on this in
   //     `polymer_expressions/lib/eval.dart` to check whether a function is a
   //     filter (takes a single argument). (Note that it's possible to include
   //     both [call] and [noSuchMethod], which would make instance-of checks
   //     work with the signature of [call], but will allow invoking the function
   //     using [noSuchMethod].
   call([a, b, c]) => invoke(receiver, methodName, [a, b, c], adjust: true);
 }