Changes in polymer-expressions to prepare for codegen in polymer:

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 12 matching lines @@
  * [Polymer expressions](http://pub.dartlang.org/packages/polymer_expressions)
  * pub repository contains detailed documentation about using polymer
  * expressions.
  */
 
 library polymer_expressions;
 
 import 'dart:async';
 import 'dart:html';
 
-import 'package:logging/logging.dart';
 import 'package:observe/observe.dart';
 import 'package:template_binding/template_binding.dart';
 
 import 'eval.dart';
 import 'expression.dart';
 import 'parser.dart';
 import 'src/globals.dart';
 
-final Logger _logger = new Logger('polymer_expressions');
-
 // TODO(justin): Investigate XSS protection
 Object _classAttributeConverter(v) =>
     (v is Map) ? v.keys.where((k) => v[k] == true).join(' ') :
     (v is Iterable) ? v.join(' ') :
     v;
 
 Object _styleAttributeConverter(v) =>
     (v is Map) ? v.keys.map((k) => '$k: ${v[k]}').join(';') :
     (v is Iterable) ? v.join(';') :
     v;
 
 class PolymerExpressions extends BindingDelegate {
   /** The default [globals] to use for Polymer expressions. */
   static const Map DEFAULT_GLOBALS = const { 'enumerate': enumerate };
 
   final Map<String, Object> globals;
 
   /**
    * Creates a new binding delegate for Polymer expressions, with the provided
    * variables used as [globals]. If no globals are supplied, a copy of the
    * [DEFAULT_GLOBALS] will be used.
    */
   PolymerExpressions({Map<String, Object> globals})
-      : globals = (globals == null) ?
+      : globals = globals == null ?
           new Map<String, Object>.from(DEFAULT_GLOBALS) : globals;
 
   prepareBinding(String path, name, node) {
     if (path == null) return null;
     var expr = new Parser(path).parse();
 
     // For template bind/repeat to an empty path, just pass through the model.
     // We don't want to unwrap the Scope.
     // TODO(jmesserly): a custom element extending <template> could notice this
     // behavior. An alternative is to associate the Scope with the node via an
@@ skipping 33 matching lines @@
   Expression _expr;
   Function _callback;
   StreamSubscription _sub;
   var _value;
 
   _Binding(this._expr, this._scope, [this._converter]);
 
   static _oneTime(Expression expr, Scope scope, [converter]) {
     try {
       return _convertValue(eval(expr, scope), scope, converter);
-    } on EvalException catch (e) {
-      _logger.warning("Error evaluating expression '$expr': ${e.message}");
-      return null;
+    } catch (e, s) {
+      new Completer().completeError(
+          "Error evaluating expression '$expr': $e", s);
     }
+    return null;
   }
 
   _setValue(v) {
     _value = _convertValue(v, _scope, _converter);
     if (_callback != null) _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) {
-        var vars = new Map();
-        vars[v.identifier] = i;
-        Scope childScope = new Scope(parent: scope, variables: vars);
-        return childScope;
-      }).toList(growable: false);
+      return v.iterable.map((i) => scope.childScope(v.identifier, i))
+          .toList(growable: false);
     } else {
       return converter == null ? v : converter(v);
     }
   }
 
   get value {
     if (_callback != null) return _value;
     return _oneTime(_expr, _scope, _converter);
   }
 
   set value(v) {
     try {
       assign(_expr, v, _scope);
-    } on EvalException catch (e) {
-      _logger.warning("Error evaluating expression '$_expr': ${e.message}");
+    } 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) {
-      _logger.warning("Error evaluating expression '$_expr': ${e.message}");
+    _sub = expr.onUpdate.listen(_setValue)..onError((e, s) {
+      new Completer().completeError(
+          "Error evaluating expression '$expr': $e", s);
     });
     try {
       update(expr, _scope);
       _value = _convertValue(expr.currentValue, _scope, _converter);
-    } on EvalException catch (e) {
-      _logger.warning("Error evaluating expression '$_expr': ${e.message}");
+    } 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;
   }
 }