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

pkg/smoke/test/common.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.
 
 /// Common test code that is run by 3 tests: mirrors_test.dart,
 /// mirrors_used_test.dart, and static_test.dart.
 library smoke.test.common;
 
 import 'package:smoke/smoke.dart' as smoke;
 import 'package:unittest/unittest.dart';
@@ skipping 122 matching lines @@
     expect(smoke.hasStaticMethod(C, #inc), isFalse);
     expect(smoke.hasStaticMethod(D, #inc), isFalse);
     expect(smoke.hasStaticMethod(D, #inc0), isFalse);
     expect(smoke.hasStaticMethod(F, #staticMethod), isTrue);
     expect(smoke.hasStaticMethod(F2, #staticMethod), isFalse);
   });
 
   test('get declaration', () {
     var d = smoke.getDeclaration(B, #a);
     expect(d.name, #a);
-    expect(d.isProperty, isTrue);
+    expect(d.isField, isTrue);
+    expect(d.isProperty, isFalse);
     expect(d.isMethod, isFalse);
     expect(d.isFinal, isFalse);
     expect(d.isStatic, isFalse);
     expect(d.annotations, []);
     expect(d.type, A);
 
     d = smoke.getDeclaration(B, #w);
     expect(d.name, #w);
+    expect(d.isField, isFalse);
     expect(d.isProperty, isTrue);
     expect(d.isMethod, isFalse);
     expect(d.isFinal, isFalse);
     expect(d.isStatic, isFalse);
     expect(d.annotations, []);
     expect(d.type, int);
 
     d = smoke.getDeclaration(A, #inc1);
     expect(d.name, #inc1);
+    expect(d.isField, isFalse);
     expect(d.isProperty, isFalse);
     expect(d.isMethod, isTrue);
     expect(d.isFinal, isFalse);
     expect(d.isStatic, isFalse);
     expect(d.annotations, []);
     expect(d.type, Function);
 
     d = smoke.getDeclaration(F, #staticMethod);
     expect(d.name, #staticMethod);
+    expect(d.isField, isFalse);
     expect(d.isProperty, isFalse);
     expect(d.isMethod, isTrue);
     expect(d.isFinal, isFalse);
     expect(d.isStatic, isTrue);
     expect(d.annotations, []);
     expect(d.type, Function);
 
     d = smoke.getDeclaration(G, #b);
     expect(d.name, #b);
-    expect(d.isProperty, isTrue);
+    expect(d.isField, isTrue);
+    expect(d.isProperty, isFalse);
     expect(d.isMethod, isFalse);
     expect(d.isFinal, isFalse);
     expect(d.isStatic, isFalse);
     expect(d.annotations, [const Annot()]);
     expect(d.type, int);
 
     d = smoke.getDeclaration(G, #d);
     expect(d.name, #d);
-    expect(d.isProperty, isTrue);
+    expect(d.isField, isTrue);
+    expect(d.isProperty, isFalse);
     expect(d.isMethod, isFalse);
     expect(d.isFinal, isFalse);
     expect(d.isStatic, isFalse);
     expect(d.annotations, [32]);
     expect(d.type, int);
   });
 
   group('query', () {
     test('default', () {
       var options = new smoke.QueryOptions();
       var res = smoke.query(A, options);
       expect(res.map((e) => e.name), [#i, #j, #j2]);
     });
 
+    test('only fields', () {
+      var options = new smoke.QueryOptions(includeProperties: false);
+      var res = smoke.query(A, options);
+      expect(res.map((e) => e.name), [#i, #j]);
+    });
+
+    test('only properties', () {
+      var options = new smoke.QueryOptions(includeFields: false);
+      var res = smoke.query(A, options);
+      expect(res.map((e) => e.name), [#j2]);
+    });
+
     test('properties and methods', () {
       var options = new smoke.QueryOptions(includeMethods: true);
       var res = smoke.query(A, options);
       expect(res.map((e) => e.name), [#i, #j, #j2, #inc0, #inc1, #inc2]);
     });
 
-    test('inherited properties', () {
+    test('inherited properties and fields', () {
       var options = new smoke.QueryOptions(includeInherited: true);
       var res = smoke.query(D, options);
       expect(res.map((e) => e.name), [#x, #y, #b, #i, #j, #j2, #x2, #i2]);
     });
 
+    test('inherited fields only', () {
+      var options = new smoke.QueryOptions(includeInherited: true,
+          includeProperties: false);
+      var res = smoke.query(D, options);
+      expect(res.map((e) => e.name), [#x, #y, #b, #i, #j]);
+    });
+
     test('exact annotation', () {
       var options = new smoke.QueryOptions(includeInherited: true,
           withAnnotations: const [a1]);
       var res = smoke.query(H, options);
       expect(res.map((e) => e.name), [#b, #f, #g]);
 
       options = new smoke.QueryOptions(includeInherited: true,
           withAnnotations: const [a2]);
       res = smoke.query(H, options);
       expect(res.map((e) => e.name), [#d, #h]);
@@ skipping 99 matching lines @@
   int c;
   @a2 int d;
 }
 
 class H extends G {
   int e;
   @a1 int f;
   @a1 int g;
   @a2 int h;
 }