Version 1.5.0-dev.4.14

dart/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 125 matching lines @@
           // a repeat with no identifier and we create new scope to occlude
           // the outer one
           if (model == existingScope.model) return existingScope;
           return _scopeFactory.modelScope(model: model, variables: globals);
         } else {
           return _getScopeForModel(template, model);
         }
       };
     }
 
-    // We have an ident, so it's a bind/as or repeat/in expression
-    assert(templateBind(template).templateInstance == null);
     return (model) {
       var existingScope = _scopes[template];
       if (existingScope != null) {
         // This only happens when a model has been assigned programatically
         // and prepareBinding is called _before_ prepareInstanceModel.
         // The scope assigned in prepareBinding wraps the model and is the
         // scope of the expression. That should be the parent of the templates
         // scope in the case of bind/as or repeat/in bindings.
         return _scopeFactory.childScope(existingScope, ident, model);
       } else {
@@ skipping 92 matching lines @@
     } else {
       return _getContainingScope(node.parentNode, model);
     }
   }
 
 }
 
 typedef Object _Converter(Object);
 
 class _Binding extends Bindable {
-  static int __seq = 1;
-
-  final int _seq = __seq++;
-
   final Scope _scope;
   final _Converter _converter;
   final Expression _expr;
+
   Function _callback;
   StreamSubscription _sub;
+  ExpressionObserver _observer;
   var _value;
 
   _Binding(this._expr, this._scope, [converter])
       : _converter = converter == null ? _identity : converter;
 
   static Object _oneTime(Expression expr, Scope scope, _Converter converter) {
     try {
       var value = eval(expr, scope);
       return (converter == null) ? value : converter(value);
     } catch (e, s) {
@@ skipping 25 matching lines @@
     } 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;
-    final expr = observe(_expr, _scope);
-//    _expr = expr;
-    _sub = expr.onUpdate.listen(_check)..onError((e, s) {
+    _observer = observe(_expr, _scope);
+    _sub = _observer.onUpdate.listen(_check)..onError((e, s) {
       new Completer().completeError(
-          "Error evaluating expression '$expr': $e", s);
+          "Error evaluating expression '$_observer': $e", s);
     });
+
     try {
       // this causes a call to _updateValue with the new value
-      update(expr, _scope);
-      _check(expr.currentValue, skipChanges: true);
+      update(_observer, _scope);
+      _check(_observer.currentValue, skipChanges: true);
     } catch (e, s) {
       new Completer().completeError(
-          "Error evaluating expression '$expr': $e", s);
+          "Error evaluating expression '$_observer': $e", s);
     }
     return _value;
   }
 
   void close() {
     if (_callback == null) return;
 
     _sub.cancel();
     _sub = null;
     _callback = null;
+
+    new Closer().visit(_observer);
+    _observer = null;
   }
 }
 
 _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);
 }