Version 1.5.0-dev.4.14

dart/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 'package:observe/observe.dart';
 import 'package:smoke/smoke.dart' as smoke;
 
 import 'async.dart';
 import 'expression.dart';
 import 'filter.dart';
 import 'visitor.dart';
 
 final _BINARY_OPERATORS = {
-  '+':  (a, b) => a + b,
-  '-':  (a, b) => a - b,
-  '*':  (a, b) => a * b,
-  '/':  (a, b) => a / b,
-  '%':  (a, b) => a % b,
-  '==': (a, b) => a == b,
-  '!=': (a, b) => a != b,
-  '>':  (a, b) => a > b,
-  '>=': (a, b) => a >= b,
-  '<':  (a, b) => a < b,
-  '<=': (a, b) => a <= b,
-  '||': (a, b) => a || b,
-  '&&': (a, b) => a && b,
-  '|':  (a, f) {
+  '+':   (a, b) => a + b,
+  '-':   (a, b) => a - b,
+  '*':   (a, b) => a * b,
+  '/':   (a, b) => a / b,
+  '%':   (a, b) => a % b,
+  '==':  (a, b) => a == b,
+  '!=':  (a, b) => a != b,
+  '===': (a, b) => identical(a, b),
+  '!==': (a, b) => !identical(a, b),
+  '>':   (a, b) => a > b,
+  '>=':  (a, b) => a >= b,
+  '<':   (a, b) => a < b,
+  '<=':  (a, b) => a <= b,
+  '||':  (a, b) => a || b,
+  '&&':  (a, b) => a && b,
+  '|':   (a, f) {
     if (f is Transformer) return f.forward(a);
     if (f is Filter) return f(a);
     throw new EvalException("Filters must be a one-argument function.");
   }
 };
 
 final _UNARY_OPERATORS = {
   '+': (a) => a,
   '-': (a) => -a,
   '!': (a) => !a,
 };
 
 final _BOOLEAN_OPERATORS = ['!', '||', '&&'];
 
 /**
  * Evaluation [expr] in the context of [scope].
  */
-Object eval(Expression expr, Scope scope) {
-  var observer = observe(expr, scope);
-  new Updater(scope).visit(observer);
-  return observer._value;
-}
+Object eval(Expression expr, Scope scope) => new EvalVisitor(scope).visit(expr);
 
 /**
  * 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().visit(expr);
@@ skipping 80 matching lines @@
 
 
 /**
  * A scope in polymer expressions that can map names to objects. Scopes contain
  * a set of named variables and a unique model object. The scope structure
  * is then used to lookup names using the `[]` operator. The lookup first
  * searches for the name in local variables, then in global variables,
  * and then finally looks up the name as a property in the model.
  */
 abstract class Scope implements Indexable<String, Object> {
-  static int __seq = 1;
-  final int _seq = __seq++;
-
   Scope._();
 
   /** Create a scope containing a [model] and all of [variables]. */
   factory Scope({Object model, Map<String, Object> variables}) {
     var scope = new _ModelScope(model);
     return variables == null ? scope
         : new _GlobalsScope(new Map<String, Object>.from(variables), scope);
   }
 
   /** Return the unique model in this scope. */
@@ skipping 13 matching lines @@
   /**
    * Returns whether [name] is defined in [model], that is, a lookup
    * would not find a variable with that name, but there is a non-null model
    * where we can look it up as a property.
    */
   bool _isModelProperty(String name);
 
   /** Create a new scope extending this scope with an additional variable. */
   Scope childScope(String name, Object value) =>
       new _LocalVariableScope(name, value, this);
-
-  String toString() => 'Scope(seq: $_seq model: $model)';
-
 }
 
 /**
  * A scope that looks up names in a model object. This kind of scope has no
  * parent scope because all our lookup operations stop when we reach the model
  * object. Any variables added in scope or global variables are added as child
  * scopes.
  */
 class _ModelScope extends Scope {
   final Object model;
@@ skipping 96 matching lines @@
 
   _updateSelf(Scope scope) {}
 
   _invalidate(Scope scope) {
     _observe(scope);
     if (_parent != null) {
       _parent._invalidate(scope);
     }
   }
 
+  _unobserve() {
+    if (_subscription != null) {
+      _subscription.cancel();
+      _subscription = null;
+    }
+  }
+
   _observe(Scope scope) {
-    // unobserve last value
-    if (_subscription != null) {
-      _subscription.cancel();
-      _subscription = null;
-    }
+    _unobserve();
 
     var _oldValue = _value;
 
     // evaluate
     _updateSelf(scope);
 
     if (!identical(_value, _oldValue)) {
       _controller.add(_value);
     }
   }
 
   String toString() => _expr.toString();
 }
 
 class Updater extends RecursiveVisitor {
   final Scope scope;
 
   Updater(this.scope);
 
   visitExpression(ExpressionObserver e) {
     e._observe(scope);
   }
 }
 
+class Closer extends RecursiveVisitor {
+  static final _instance = new Closer._();
+  factory Closer() => _instance;
+  Closer._();
+
+  visitExpression(ExpressionObserver e) {
+    e._unobserve();
+  }
+}
+
+class EvalVisitor extends Visitor {
+  final Scope scope;
+
+  EvalVisitor(this.scope);
+
+  visitEmptyExpression(EmptyExpression e) => scope.model;
+
+  visitParenthesizedExpression(ParenthesizedExpression e) => visit(e.child);
+
+  visitGetter(Getter g) {
+    var receiver = visit(g.receiver);
+    if (receiver == null) return null;
+    var symbol = smoke.nameToSymbol(g.name);
+    return smoke.read(receiver, symbol);
+  }
+
+  visitIndex(Index i) {
+    var receiver = visit(i.receiver);
+    if (receiver == null) return null;
+    var key = visit(i.argument);
+    return receiver[key];
+  }
+
+  visitInvoke(Invoke i) {
+    var receiver = visit(i.receiver);
+    if (receiver == null) return null;
+    var args = (i.arguments == null)
+        ? null
+        : i.arguments.map(visit).toList(growable: false);
+
+    if (i.method == null) {
+      assert(receiver is Function);
+      return Function.apply(receiver, args);
+    }
+
+    var symbol = smoke.nameToSymbol(i.method);
+    return smoke.invoke(receiver, symbol, args);
+  }
+
+  visitLiteral(Literal l) => l.value;
+
+  visitListLiteral(ListLiteral l) => l.items.map(visit).toList();
+
+  visitMapLiteral(MapLiteral l) {
+    var map = {};
+    for (var entry in l.entries) {
+      var key = visit(entry.key);
+      var value = visit(entry.entryValue);
+      map[key] = value;
+    }
+    return map;
+  }
+
+  visitMapLiteralEntry(MapLiteralEntry e) =>
+      throw new UnsupportedError("should never be called");
+
+  visitIdentifier(Identifier i) => scope[i.value];
+
+  visitBinaryOperator(BinaryOperator o) {
+    var operator = o.operator;
+    var left = visit(o.left);
+    var right = visit(o.right);
+
+    var f = _BINARY_OPERATORS[operator];
+    if (operator == '&&' || operator == '||') {
+      // TODO: short-circuit
+      return f(_toBool(left), _toBool(right));
+    } else if (operator == '==' || operator == '!=') {
+      return f(left, right);
+    } else if (left == null || right == null) {
+      return null;
+    }
+    return f(left, right);
+  }
+
+  visitUnaryOperator(UnaryOperator o) {
+    var expr = visit(o.child);
+    var f = _UNARY_OPERATORS[o.operator];
+    if (o.operator == '!') {
+      return f(_toBool(expr));
+    }
+    return (expr == null) ? null : f(expr);
+  }
+
+  visitTernaryOperator(TernaryOperator o) =>
+      visit(o.condition) == true ? visit(o.trueExpr) : visit(o.falseExpr);
+
+  visitInExpression(InExpression i) =>
+      throw new UnsupportedError("can't eval an 'in' expression");
+
+  visitAsExpression(AsExpression i) =>
+      throw new UnsupportedError("can't eval an 'as' expression");
+}
+
 class ObserverBuilder extends Visitor {
   final Queue parents = new Queue();
 
   ObserverBuilder();
 
   visitEmptyExpression(EmptyExpression e) => new EmptyObserver(e);
 
   visitParenthesizedExpression(ParenthesizedExpression e) => visit(e.child);
 
   visitGetter(Getter g) {
@@ skipping 113 matching lines @@
 }
 
 class ListLiteralObserver extends ExpressionObserver<ListLiteral>
     implements ListLiteral {
 
   final List<ExpressionObserver> items;
 
   ListLiteralObserver(ListLiteral value, this.items) : super(value);
 
   _updateSelf(Scope scope) {
-    _value = items.map((i) => i._value).toList(growable: false);
+    _value = items.map((i) => i._value).toList();
   }
 
   accept(Visitor v) => v.visitListLiteral(this);
 }
 
 class MapLiteralObserver extends ExpressionObserver<MapLiteral>
     implements MapLiteral {
 
   final List<MapLiteralEntryObserver> entries;
 
@@ skipping 230 matching lines @@
   accept(Visitor v) => v.visitInvoke(this);
 }
 
 _toBool(v) => (v == null) ? false : v;
 
 class EvalException implements Exception {
   final String message;
   EvalException(this.message);
   String toString() => "EvalException: $message";
 }