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

pkg/observe/lib/src/path_observer.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.
 
 library observe.src.path_observer;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:math' show min;
 @MirrorsUsed(metaTargets: const [Reflectable, ObservableProperty],
-    override: 'observe.src.path_observer')
-import 'dart:mirrors';
+    override: 'smoke.mirrors')
+import 'dart:mirrors' show MirrorsUsed;
+
 import 'package:logging/logging.dart' show Logger, Level;
 import 'package:observe/observe.dart';
 import 'package:observe/src/observable.dart' show objectType;
+import 'package:smoke/smoke.dart' as smoke;
 
 /// A data-bound path starting from a view-model or model object, for example
 /// `foo.bar.baz`.
 ///
 /// When [open] is called, this will observe changes to the object and any
 /// intermediate object along the path, and send updated values accordingly.
 /// When [close] is called it will stop observing the objects.
 ///
 /// This class is used to implement `Node.bind` and similar functionality in
 /// the [template_binding](pub.dartlang.org/packages/template_binding) package.
 class PathObserver extends _Observer implements Bindable {
   PropertyPath _path;
   Object _object;
   _ObservedSet _directObserver;
 
   /// Observes [path] on [object] for changes. This returns an object
   /// that can be used to get the changes and get/set the value at this path.
   ///
   /// The path can be a [PropertyPath], or a [String] used to construct it.
   ///
   /// See [open] and [value].
   PathObserver(Object object, [path])
       : _object = object,
         _path = path is PropertyPath ? path : new PropertyPath(path);
 
   bool get _isClosed => _path == null;
 
   /// Sets the value at this path.
-  @reflectable void set value(Object newValue) {
+  void set value(Object newValue) {
     if (_path != null) _path.setValueFrom(_object, newValue);
   }
 
   int get _reportArgumentCount => 2;
 
   /// Initiates observation and returns the initial value.
   /// The callback will be passed the updated [value], and may optionally be
   /// declared to take a second argument, which will contain the previous value.
   open(callback) => super.open(callback);
 
@@ skipping 86 matching lines @@
 
   PropertyPath._(this._segments);
 
   int get length => _segments.length;
   bool get isEmpty => _segments.isEmpty;
   bool get isValid => true;
 
   String toString() {
     if (!isValid) return '<invalid path>';
     return _segments
-        .map((s) => s is Symbol ? MirrorSystem.getName(s) : s)
+        .map((s) => s is Symbol ? smoke.symbolToName(s) : s)
         .join('.');
   }
 
   bool operator ==(other) {
     if (identical(this, other)) return true;
     if (other is! PropertyPath) return false;
     if (isValid != other.isValid) return false;
 
     int len = _segments.length;
     if (len != other._segments.length) return false;
@@ skipping 60 matching lines @@
 
   bool get isValid => false;
   _InvalidPropertyPath() : super._([]);
 }
 
 bool _changeRecordMatches(record, key) {
   if (record is PropertyChangeRecord) {
     return (record as PropertyChangeRecord).name == key;
   }
   if (record is MapChangeRecord) {
-    if (key is Symbol) key = MirrorSystem.getName(key);
+    if (key is Symbol) key = smoke.symbolToName(key);
     return (record as MapChangeRecord).key == key;
   }
   return false;
 }
 
 _getObjectProperty(object, property) {
   if (object == null) return null;
 
   if (property is int) {
     if (object is List && property >= 0 && property < object.length) {
       return object[property];
     }
   } else if (property is Symbol) {
-    var mirror = reflect(object);
-    final type = mirror.type;
+    final type = object.runtimeType;
     try {
-      if (_maybeHasGetter(type, property)) {
-        return mirror.getField(property).reflectee;
+      if (smoke.hasGetter(type, property) || smoke.hasNoSuchMethod(type)) {
+        return smoke.read(object, property);
       }
       // Support indexer if available, e.g. Maps or polymer_expressions Scope.
       // This is the default syntax used by polymer/nodebind and
       // polymer/observe-js PathObserver.
-      if (_hasMethod(type, const Symbol('[]'))) {
-        return object[MirrorSystem.getName(property)];
+      if (smoke.hasInstanceMethod(type, const Symbol('[]'))) {
+        return object[smoke.symbolToName(property)];
       }
     } on NoSuchMethodError catch (e) {
       // Rethrow, unless the type implements noSuchMethod, in which case we
       // interpret the exception as a signal that the method was not found.
-      if (!_hasMethod(type, #noSuchMethod)) rethrow;
+      if (!smoke.hasNoSuchMethod(type)) rethrow;
     }
   }
 
   if (_logger.isLoggable(Level.FINER)) {
     _logger.finer("can't get $property in $object");
   }
   return null;
 }
 
 bool _setObjectProperty(object, property, value) {
   if (object == null) return false;
 
   if (property is int) {
     if (object is List && property >= 0 && property < object.length) {
       object[property] = value;
       return true;
     }
   } else if (property is Symbol) {
-    var mirror = reflect(object);
-    final type = mirror.type;
+    final type = object.runtimeType;
     try {
-      if (_maybeHasSetter(type, property)) {
-        mirror.setField(property, value);
+      if (smoke.hasSetter(type, property) || smoke.hasNoSuchMethod(type)) {
+        smoke.write(object, property, value);
         return true;
       }
       // Support indexer if available, e.g. Maps or polymer_expressions Scope.
-      if (_hasMethod(type, const Symbol('[]='))) {
-        object[MirrorSystem.getName(property)] = value;
+      if (smoke.hasInstanceMethod(type, const Symbol('[]='))) {
+        object[smoke.symbolToName(property)] = value;
         return true;
       }
     } on NoSuchMethodError catch (e) {
-      if (!_hasMethod(type, #noSuchMethod)) rethrow;
+      if (!smoke.hasNoSuchMethod(type)) rethrow;
     }
   }
 
   if (_logger.isLoggable(Level.FINER)) {
     _logger.finer("can't set $property in $object");
   }
   return false;
 }
 
-bool _maybeHasGetter(ClassMirror type, Symbol name) {
-  while (type != objectType) {
-    final members = type.declarations;
-    if (members.containsKey(name)) return true;
-    if (members.containsKey(#noSuchMethod)) return true;
-    type = _safeSuperclass(type);
-  }
-  return false;
-}
-
-// TODO(jmesserly): workaround for:
-// https://code.google.com/p/dart/issues/detail?id=10029
-Symbol _setterName(Symbol getter) =>
-    new Symbol('${MirrorSystem.getName(getter)}=');
-
-bool _maybeHasSetter(ClassMirror type, Symbol name) {
-  var setterName = _setterName(name);
-  while (type != objectType) {
-    final members = type.declarations;
-    if (members[name] is VariableMirror) return true;
-    if (members.containsKey(setterName)) return true;
-    if (members.containsKey(#noSuchMethod)) return true;
-    type = _safeSuperclass(type);
-  }
-  return false;
-}
-
-/// True if the type has a method, other than on Object.
-/// Doesn't consider noSuchMethod, unless [name] is `#noSuchMethod`.
-bool _hasMethod(ClassMirror type, Symbol name) {
-  while (type != objectType) {
-    final member = type.declarations[name];
-    if (member is MethodMirror && member.isRegularMethod) return true;
-    type = _safeSuperclass(type);
-  }
-  return false;
-}
-
-ClassMirror _safeSuperclass(ClassMirror type) {
-  try {
-    return type.superclass;
-  } /*on UnsupportedError*/ catch (e) {
-    // Note: dart2js throws UnsupportedError when the type is not
-    // reflectable.
-    // TODO(jmesserly): dart2js also throws a NoSuchMethodError if the `type` is
-    // a bound generic, because they are not fully implemented. See
-    // https://code.google.com/p/dart/issues/detail?id=15573
-    return objectType;
-  }
-}
-
 // From: https://github.com/rafaelw/ChangeSummary/blob/master/change_summary.js
 
 final _pathRegExp = () {
   const identStart = '[\$_a-zA-Z]';
   const identPart = '[\$_a-zA-Z0-9]';
   const ident = '$identStart+$identPart*';
   const elementIndex = '(?:[0-9]|[1-9]+[0-9]+)';
   const identOrElementIndex = '(?:$ident|$elementIndex)';
   const path = '(?:$identOrElementIndex)(?:\\.$identOrElementIndex)*';
   return new RegExp('^$path\$');
@@ skipping 199 matching lines @@
     }
 
     _notifyCallback = callback;
     _notifyArgumentCount = min(_reportArgumentCount,
         _maxArgumentCount(callback));
 
     _connect();
     return _value;
   }
 
-  @reflectable get value {
+  get value {
     _check(skipChanges: true);
     return _value;
   }
 
   void close() {
     if (!_isOpen) return;
 
     _disconnect();
     _value = null;
     _notifyCallback = null;
@@ skipping 145 matching lines @@
     for (var observer in _observers.values.toList(growable: false)) {
       if (observer._isOpen) observer._check();
     }
 
     _resetNeeded = true;
     scheduleMicrotask(reset);
   }
 }
 
 const int _MAX_DIRTY_CHECK_CYCLES = 1000;