Remove Comprehension type in polymer expressions

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 92 matching lines @@
 }
 
 class _Binding extends Bindable {
   final Scope _scope;
   final _converter;
   Expression _expr;
   Function _callback;
   StreamSubscription _sub;
   var _value;
 
-  _Binding(this._expr, this._scope, [this._converter]);
+  _Binding(this._expr, this._scope, [converter])
+      : _converter = converter == null ? _identity : converter;
 
   static _oneTime(Expression expr, Scope scope, [converter]) {
     try {
-      return _convertValue(eval(expr, scope), scope, converter);
+      var v = eval(expr, scope);
+      return converter == null ? v : converter(v);
     } catch (e, s) {
       new Completer().completeError(
           "Error evaluating expression '$expr': $e", s);
     }
     return null;
   }
 
-  _setValue(v) {
+  _check(v, {bool skipChanges: false}) {

[Siggi Cherem (dart-lang), 2014/05/30 21:36:03]

this rename is not necessary, but it makes the code match closer what we do in
path_observer.dart. I'm happy to revert it if you prefer it like it was.

[justinfagnani, 2014/05/30 22:58:33]

Please make as few changes as possible, it makes my job rebasing the CL I have
outstanding much easier.

[Jennifer Messerly, 2014/05/30 23:00:56]

yeah, sorry about rebase difficulty.

But I just wanted to say Siggi: I really like these changes. Brining it more in
line with Rafael's observe-js style makes it much easier for me to read and
reason about. +1

     var oldValue = _value;
-    _value = _convertValue(v, _scope, _converter);
-    if (_callback != null && oldValue != _value) _callback(_value);
-  }
-
-  static _convertValue(v, scope, converter) {
-    if (v is Comprehension) {
-      // convert the Comprehension into a list of scopes with the loop
-      // variable added to the scope
-      return v.iterable.map((i) => scope.childScope(v.identifier, i))
-          .toList(growable: false);
-    } else {
-      return converter == null ? v : converter(v);
+    _value = _converter(v);
+    if (!skipChanges && _callback != null && oldValue != _value) {
+      _callback(_value);
     }
   }
 
   get value {
     if (_callback != null) return _value;
     return _oneTime(_expr, _scope, _converter);
   }
 
   set value(v) {
     try {
       var newValue = assign(_expr, v, _scope);
-      _value = _convertValue(newValue, _scope, _converter);
+      _check(newValue, skipChanges: true);
     } catch (e, s) {
       new Completer().completeError(
           "Error evaluating expression '$_expr': $e", s);
     }
   }
 
   open(callback(value)) {
     if (_callback != null) throw new StateError('already open');
 
     _callback = callback;
     final expr = observe(_expr, _scope);
     _expr = expr;
-    _sub = expr.onUpdate.listen(_setValue)..onError((e, s) {
+    _sub = expr.onUpdate.listen(_check)..onError((e, s) {
       new Completer().completeError(
           "Error evaluating expression '$expr': $e", s);
     });
     try {
       update(expr, _scope);
-      _value = _convertValue(expr.currentValue, _scope, _converter);
+      _check(expr.currentValue, skipChanges: true);
     } catch (e, s) {
       new Completer().completeError(
           "Error evaluating expression '$expr': $e", s);
     }
     return _value;
   }
 
   void close() {
     if (_callback == null) return;
 
     _sub.cancel();
     _sub = null;
     _expr = (_expr as ExpressionObserver).expression;
     _callback = null;
   }
 }
+
+_identity(x) => x;