Silently handle handle eval exceptions in PolymerExpressions

pkg/polymer_expressions/lib/eval.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.
 
 library polymer_expressions.eval;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:mirrors';
 
@@ skipping 29 matching lines @@
   '+': (a) => a,
   '-': (a) => -a,
   '!': (a) => !a,
 };
 
 final _BOOLEAN_OPERATORS = ['!', '||', '&&'];
 
 /**
  * Evaluation [expr] in the context of [scope].
  */
-Object eval(Expression expr, Scope scope) => observe(expr, scope)._value;
+Object eval(Expression expr, Scope scope) {
+  var observer = observe(expr, scope);
+  new Updater(scope).visit(observer);
+  return observer._value;
+}
 
-
+/**
+ * Returns an [ExpressionObserver] that evaluates [expr] in the context of
+ * scope] and listens for any changes on [Observable] values that are
+ * returned from sub-expressions. When a value changes the expression is
+ * reevaluated and the new result is sent to the [onUpdate] stream of the
+ * [ExpressionObsserver].
+ */
 ExpressionObserver observe(Expression expr, Scope scope) {
   var observer = new ObserverBuilder(scope).visit(expr);
-  new Updater(scope).visit(observer);
   return observer;
 }
 
 /**
+ * Causes [expr] to be reevaluated a returns it's value.
+ */
+Object update(ExpressionObserver expr, Scope scope) {
+  new Updater(scope).visit(expr);
+  return expr.currentValue;
+}
+
+/**
  * Assign [value] to the variable or field referenced by [expr] in the context
  * of [scope].
  *
  * [expr] must be an /assignable/ expression, it must not contain
  * operators or function invocations, and any index operations must use a
  * literal index.
  */
 void assign(Expression expr, Object value, Scope scope) {
 
   notAssignable() =>
@@ skipping 89 matching lines @@
       if (memberMirror is VariableMirror ||
           (memberMirror is MethodMirror && memberMirror.isGetter)) {
         return _convert(_modelMirror.getField(symbol).reflectee);
       } else if (memberMirror is MethodMirror) {
         return new Method(_modelMirror, symbol);
       }
     }
     if (parent != null) {
       return _convert(parent[name]);
     } else {
-      throw new EvalException("variable not found: $name in $hashCode");
+      throw new EvalException("variable '$name' not found");
     }
   }
 
   Object ownerOf(String name) {
     if (name == 'this') {
       // we could return the Scope if it were Observable, but since assigning
       // a model to a template destroys and recreates the instance, it doesn't
       // seem neccessary
       return null;
     } else if (_variables.containsKey(name)) {
@@ skipping 18 matching lines @@
       var classMirror = _modelMirror.type;
       if (getMemberMirror(classMirror, symbol) != null) {
         return true;
       }
     }
     if (parent != null) {
       return parent.contains(name);
     }
     return false;
   }
-
-  String toString() => 'Scope($hashCode $parent)';
 }
 
 Object _convert(v) {
   if (v is Stream) return new StreamBinding(v);
   return v;
 }
 
 abstract class ExpressionObserver<E extends Expression> implements Expression {
   final E _expr;
   ExpressionObserver _parent;
@@ skipping 397 matching lines @@
   Method(this.mirror, this.symbol);
 
   dynamic call(List args) => mirror.invoke(symbol, args, null).reflectee;
 }
 
 class EvalException implements Exception {
   final String message;
   EvalException(this.message);
   String toString() => "EvalException: $message";
 }