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).
   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?
   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.
+  bool get isField => _kind == FIELD;
+
+  /// Whether the symbol is a getter/setter and not a field.

[Siggi Cherem (dart-lang), 2014/02/21 18:02:58]

I was thinking more about it this morning, and I'm not convinced about making
isProperty false for fields. Some people might find that surprising or
unintuitive.

Alternatively we could do the following:

in declaration: isField implies isProperty
in query options:
  - includeProperties: query for both fields and properties
  - excludeGetters:  exclude getters from the property results

Thoughts?

[Jennifer Messerly, 2014/02/21 23:29:11]

Tricky. What you have right now is fairly consistent with mirrors, which doesn't
expose the "induced getter/setter" for fields, so on that count it's okay. In
mirrors I think it works okay to expose closer to what the source code says,
since sometimes that distinction matters (as it does for Observable).

excludeGetters seems confusing -- why getters and not setters?

but yeah, I can also see "isProperty" including fields. The way the
"DeclarationKind" enum is set up certainly would make me lean towards having
them separate.

[Siggi Cherem (dart-lang), 2014/02/22 01:13:28]

ok, thanks - I went with keeping them separate and adjusted the comments to be
more explicit about it.

+  bool get isProperty => _kind == PROPERTY;
+
+  /// Whether the symbol is a method.
+  bool get isMethod => _kind == METHOD;
 
   /// If this is a property, whether it's read only (final fields or properties
   /// with 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.
   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,
-      this.isFinal: false, this.isStatic: false, this.annotations: const []});
+  const Declaration(this.name, this.type, {DeclarationKind kind: FIELD,
+      this.isFinal: false, this.isStatic: false, this.annotations: const []})
+      : _kind = kind;
 
   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 {

[Jennifer Messerly, 2014/02/21 23:29:11]

if _kind is private, then DeclarationKind should be too, IMO. Or alternatively
expose Declaration.kind

[Siggi Cherem (dart-lang), 2014/02/22 01:13:28]

yeah, I was ambivalent about it. I decided to expose it in Declaration.kind in
the end. Constructing the declaration (see static_test.dart) is much nicer if
this is exposed.

+  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);
 }