Log exceptions caught 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 82 matching lines @@
       : _expr = observe(expr, scope),
         _scope = scope {
     _expr.onUpdate.listen(_setValue).onError((e) {
       _logger.warning("Error evaluating expression '$_expr': ${e.message}");
     });
     try {
       update(_expr, _scope);
       _setValue(_expr.currentValue);
     } on EvalException catch (e) {
       _logger.warning("Error evaluating expression '$_expr': ${e.message}");
+    } catch (e) {

[Siggi Cherem (dart-lang), 2013/10/08 23:41:08]

should I merge this and the catch above together? I saw in many places we only
check for EvalException, but I wonder if we want to consistently catch
everything or only catch EvalExceptions?

[Jennifer Messerly, 2013/10/15 22:47:15]

IMO: only EvalException in both places.

[justinfagnani, 2013/10/16 00:37:08]

same, other exceptions are real application exceptions and not just nulls in the
binding path.

+      _logger.warning("Error evaluating expression '$_expr': ${e}");
     }
   }
 
   _setValue(v) {
     if (v is Comprehension) {
       // convert the Comprehension into a list of scopes with the loop
       // variable added to the scope
       _value = 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);
     } else {
       _value = (_converter == null) ? v : _converter(v);
     }
     notifyChange(new PropertyChangeRecord(_VALUE));
   }
 
   get value => _value;
 
   set value(v) {
     try {
       assign(_expr, v, _scope);
       notifyChange(new PropertyChangeRecord(_VALUE));
-    } on EvalException catch (e) {
-      // silently swallow binding errors
+    } catch (e) {
+      _logger.warning("Error evaluating expression '$_expr': $e");
     }
   }
 
   getValueWorkaround(key) {
     if (key == _VALUE) return value;
   }
 
   setValueWorkaround(key, v) {
     if (key == _VALUE) value = v;
   }
 
 }