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

pkg/smoke/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 66 matching lines @@
     implementation.symbolConverter.symbolToName(symbol);
 
 /// Returns the symbol associated with a [name].
 Symbol nameToSymbol(String name) =>
     implementation.symbolConverter.nameToSymbol(name);
 
 /// Establishes the parameters for [query] to search for symbols in a type
 /// hierarchy. For now only public instance symbols can be queried (no private,
 /// no static).
 class QueryOptions {
-  /// Whether to include fields, getters, and setters.
+  /// Whether to include fields (default is true).
+  final bool includeFields;
+
+  /// Whether to include getters and setters (default is true). Note that to
+  /// include fields you also need to enable [includeFields].
   final bool includeProperties;
 
   /// Whether to include symbols from the given type and its superclasses
   /// (except [Object]).
   final bool includeInherited;
 
-  /// Whether to include final fields.
-  // TODO(sigmund): should this exclude getter-only properties too?
+  /// Whether to include final fields and getter-only properties.
   final bool excludeFinal;
 
   /// Whether to include methods (default is false).
   final bool includeMethods;
 
   /// 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;
 
-  const QueryOptions({this.includeProperties: true, this.includeInherited: true,
-      this.excludeFinal: false, this.includeMethods: false,
+  const QueryOptions({
+      this.includeFields: true,
+      this.includeProperties: true,
+      this.includeInherited: true,
+      this.excludeFinal: false,
+      this.includeMethods: false,
       this.withAnnotations: null});
 }
 
 /// Information associated with a symbol declaration (like a property or
 /// method).
 class Declaration {
   /// Name of the property or method
   final Symbol name;
 
-  /// Whether the symbol is a property (either this or [isMethod] is true).
-  bool get isProperty => !isMethod;
+  /// Kind of declaration (field, property, or method).
+  final DeclarationKind kind;
 
-  /// Whether the symbol is a method (either this or [isProperty] is true)
-  final bool isMethod;
+  /// Whether the symbol is a field (and not a getter/setter property).
+  bool get isField => kind == FIELD;
 
-  /// If this is a property, whether it's read only (final fields or properties
-  /// with no setter).
+  /// Whether the symbol is a getter/setter and not a field.
+  bool get isProperty => kind == PROPERTY;
+
+  /// Whether the symbol is a method.
+  bool get isMethod => kind == METHOD;
+
+  /// For fields, whether they are final, for properties, whether they are
+  /// read-only (they have no setter).
   final bool isFinal;
 
-  /// If this is a property, it's declared type (including dynamic if it's not
-  /// declared). For methods, the returned type.
+  /// If this is a field or property, it's declared type (including dynamic if
+  /// it's not declared). For methods, the returned type.
   final Type type;
 
   /// Whether this symbol is static.
   final bool isStatic;
 
   /// List of annotations in this declaration.
   final List annotations;
 
-  const Declaration(this.name, this.type, {this.isMethod:false,
+  const Declaration(this.name, this.type, {this.kind: FIELD,
       this.isFinal: false, this.isStatic: false, this.annotations: const []});
 
   String toString() {
     return (new StringBuffer()
         ..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);
 
@@ skipping 28 matching lines @@
 
 
 /// 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);
 }