switch Node.bind to interop

pkg/polymer_expressions/lib/polymer_expressions.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.
 
 /**
  * A binding delegate used with Polymer elements that
  * allows for complex binding expressions, including
  * property access, function invocation,
  * list/map indexing, and two-way filtering.
  *
@@ skipping 260 matching lines @@
     try {
       var value = eval(expr, scope);
       return (converter == null) ? value : converter(value);
     } catch (e, s) {
       new Completer().completeError(
           "Error evaluating expression '$expr': $e", s);
     }
     return null;
   }
 
-  _check(v, {bool skipChanges: false}) {
+  bool _convertAndCheck(newValue, {bool skipChanges: false}) {
     var oldValue = _value;
-    _value = _converter(v);
+    _value = _converter(newValue);
+
     if (!skipChanges && _callback != null && oldValue != _value) {
       _callback(_value);
+      return true;
     }
+    return false;
   }
 
+  // TODO(jmesserly): this should discard changes, but it caused
+  // a strange infinite loop in one of the bindings_tests.
+  // For now skipping the test. See http://dartbug.com/19105.
   get value {
     // if there's a callback, then _value has been set, if not we need to
     // force an evaluation
     if (_callback != null) return _value;
     return _oneTime(_expr, _scope, _converter);
   }
 
   set value(v) {
     try {
       var newValue = assign(_expr, v, _scope, checkAssignability: false);
-      _check(newValue, skipChanges: true);
+      _convertAndCheck(newValue);
     } catch (e, s) {
       new Completer().completeError(
           "Error evaluating expression '$_expr': $e", s);
     }
   }
 
   Object open(callback(value)) {
     if (_callback != null) throw new StateError('already open');
 
     _callback = callback;
     _observer = observe(_expr, _scope);
-    _sub = _observer.onUpdate.listen(_check)..onError((e, s) {
+    _sub = _observer.onUpdate.listen(_convertAndCheck)..onError((e, s) {
       new Completer().completeError(
           "Error evaluating expression '$_observer': $e", s);
     });
 
+    _check(skipChanges: true);
+    return _value;
+  }
+
+  bool _check({bool skipChanges: false}) {
     try {
       // this causes a call to _updateValue with the new value
       update(_observer, _scope);
-      _check(_observer.currentValue, skipChanges: true);
+      return _convertAndCheck(_observer.currentValue, skipChanges: skipChanges);
     } catch (e, s) {
       new Completer().completeError(
           "Error evaluating expression '$_observer': $e", s);
+      return false;
     }
-    return _value;
   }
 
   void close() {
     if (_callback == null) return;
 
     _sub.cancel();
     _sub = null;
     _callback = null;
 
     new Closer().visit(_observer);
     _observer = null;
   }
+
+
+  // TODO(jmesserly): the following code is copy+pasted from path_observer.dart
+  // What seems to be going on is: polymer_expressions.dart has its own _Binding
+  // unlike polymer-expressions.js, which builds on CompoundObserver.
+  // This can lead to subtle bugs and should be reconciled. I'm not sure how it
+  // should go, but CompoundObserver does have some nice optimizations around
+  // ObservedSet which are lacking here. And reuse is nice.
+  void deliver() {
+    if (_callback != null) _dirtyCheck();
+  }
+
+  bool _dirtyCheck() {
+    var cycles = 0;
+    while (cycles < _MAX_DIRTY_CHECK_CYCLES && _check()) {
+      cycles++;
+    }
+    return cycles > 0;
+  }
+
+  static const int _MAX_DIRTY_CHECK_CYCLES = 1000;
 }
 
 _identity(x) => x;
 
 /**
  * Factory function used for testing.
  */
 class ScopeFactory {
   const ScopeFactory();
   modelScope({Object model, Map<String, Object> variables}) =>
       new Scope(model: model, variables: variables);
 
   childScope(Scope parent, String name, Object value) =>
       parent.childScope(name, value);
 }