fix observing superclass fields, issue 13255

pkg/observe/lib/src/observable.dart

 // Copyright (c) 2013, 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.
 
 part of observe;
 
 /**
  * Use `@observable` to make a field automatically observable.
  */
 const Object observable = const _ObservableAnnotation();
@@ skipping 79 matching lines @@
  * When a field, property, or indexable item is changed, the change record
  * will be sent to [changes].
  */
 abstract class ObservableMixin implements Observable {
   StreamController _changes;
   InstanceMirror _mirror;
 
   Map<Symbol, Object> _values;
   List<ChangeRecord> _records;
 
+  static final _objectType = reflectClass(Object);
+
   Stream<List<ChangeRecord>> get changes {
     if (_changes == null) {
       _changes = new StreamController.broadcast(sync: true,
           onListen: _observed, onCancel: _unobserved);
     }
     return _changes.stream;
   }
 
   bool get hasObservers => _changes != null && _changes.hasListener;
 
   void _observed() {
     // Register this object for dirty checking purposes.
     registerObservable(this);
 
     var mirror = reflect(this);
     var values = new Map<Symbol, Object>();
 
-    // TODO(jmesserly): this should consider the superclass. Unfortunately
-    // that is not possible right now because of:
-    // http://code.google.com/p/dart/issues/detail?id=9434
-    for (var field in mirror.type.variables.values) {
-      if (field.isFinal || field.isStatic || field.isPrivate) continue;
+    // Note: we scan for @observable regardless of whether the base type
+    // actually includes this mixin. While perhaps too inclusive, it lets us
+    // avoid complex logic that walks "with" and "implements" clauses.
+    for (var type = mirror.type; type != _objectType; type = type.superclass) {
+      for (var field in type.variables.values) {
+        if (field.isFinal || field.isStatic || field.isPrivate) continue;
 
-      for (var meta in field.metadata) {
-        if (identical(observable, meta.reflectee)) {
-          var name = field.simpleName;
-          // Note: since this is a field, getting the value shouldn't execute
-          // user code, so we don't need to worry about errors.
-          values[name] = mirror.getField(name).reflectee;
-          break;
+        for (var meta in field.metadata) {
+          if (identical(observable, meta.reflectee)) {
+            var name = field.simpleName;
+            // Note: since this is a field, getting the value shouldn't execute
+            // user code, so we don't need to worry about errors.
+            values[name] = mirror.getField(name).reflectee;
+            break;
+          }
         }
       }
     }
 
     _mirror = mirror;
     _values = values;
   }
 
   /** Release data associated with observation. */
   void _unobserved() {
@@ skipping 78 matching lines @@
 /**
  * The type of the `@observable` annotation.
  *
  * Library private because you should be able to use the [observable] field
  * to get the one and only instance. We could make it public though, if anyone
  * needs it for some reason.
  */
 class _ObservableAnnotation {
   const _ObservableAnnotation();
 }