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) ?
-          new Map<String, Object>.from(DEFAULT_GLOBALS) : globals;
+      : globals = globals == null ? DEFAULT_GLOBALS : globals;

[Siggi Cherem (dart-lang), 2014/03/21 01:43:46]

I don't copy it here anymore because we now use the map as read-only. Scopes
create their copy internally.

[Jennifer Messerly, 2014/03/21 20:08:54]

Hmmm, the idea here was that users can dynamically add to globals (probably just
at startup) to the Polymer syntax, similar to JS. If we take that away we should
at least fix the spots in Polymer where the user has no control. Actually our
_PolymerExpressionsWithEventDelegate looks like it became totally private again
:| ... not sure how folks are supposed to be able to customize it in Dart.

[Siggi Cherem (dart-lang), 2014/03/21 21:09:47]

Done. Made _PolymerExpressionsWithEventDelegate public as well. I think people
were doing customization by recreating that class (coping the body of
prepareBinding) :-/

 
   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
     // Expando, which is what the JavaScript PolymerExpressions does.
@@ skipping 32 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(

[Jennifer Messerly, 2014/03/21 20:08:54]

nice!

+          "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;
   }
 }