Refactor of PolymerExpressions. Adds "as" expressions.

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';
@@ skipping 42 matching lines @@
 }
 
 /**
  * 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);
+  var observer = new ObserverBuilder().visit(expr);
   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;
 }
@@ skipping 70 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;
 
   _ModelScope(this.model) : super._();
 
   Object operator[](String name) {
     if (name == 'this') return model;
     var symbol = smoke.nameToSymbol(name);
     if (model == null || symbol == null) {
       throw new EvalException("variable '$name' not found");
     }
     return _convert(smoke.read(model, symbol));
   }
 
   Object _isModelProperty(String name) => name != 'this';
+
+  String toString() => 'ModelScope(model: $model)';
 }
 
 /**
  * A scope that holds a reference to a single variable. Polymer expressions
  * introduce variables to the scope one at a time. Each time a variable is
  * added, a new [_LocalVariableScope] is created.
  */
 class _LocalVariableScope extends Scope {
   final Scope parent;
   final String varName;
@@ skipping 11 matching lines @@
   Object operator[](String name) {
     if (varName == name) return _convert(value);
     if (parent != null) return parent[name];
     throw new EvalException("variable '$name' not found");
   }
 
   bool _isModelProperty(String name) {
     if (varName == name) return false;
     return parent == null ? false : parent._isModelProperty(name);
   }
+
+  String toString() => 'LocalVariableScope(varName: $varName, value: $value, parent: $parent)';

[Jennifer Messerly, 2014/04/24 00:51:34]

long line

[justinfagnani, 2014/05/28 00:29:37]

Done.

 }
 
 /** A scope that holds a reference to a global variables. */
 class _GlobalsScope extends Scope {
   final _ModelScope parent;
   final Map<String, Object> variables;
 
   _GlobalsScope(this.variables, this.parent) : super._() {
     if (variables.containsKey('this')) {
       throw new EvalException("'this' cannot be used as a variable name.");
     }
   }
 
   Object get model => parent != null ? parent.model : null;
 
   Object operator[](String name) {
     if (variables.containsKey(name)) return _convert(variables[name]);
     if (parent != null) return parent[name];
     throw new EvalException("variable '$name' not found");
   }
 
   bool _isModelProperty(String name) {
     if (variables.containsKey(name)) return false;
     return parent == null ? false : parent._isModelProperty(name);
   }
+
+  String toString() => 'GlobalsScope(variables: $variables, parent: $parent)';
 }
 
 Object _convert(v) => v is Stream ? new StreamBinding(v) : v;
 
 abstract class ExpressionObserver<E extends Expression> implements Expression {
   final E _expr;
   ExpressionObserver _parent;
 
   StreamSubscription _subscription;
   Object _value;
@@ skipping 39 matching lines @@
 }
 
 class Updater extends RecursiveVisitor {
   final Scope scope;
 
   Updater(this.scope);
 
   visitExpression(ExpressionObserver e) {
     e._observe(scope);
   }
-
-  visitInExpression(InObserver c) {
-    visit(c.right);
-    visitExpression(c);
-  }
 }
 
 class ObserverBuilder extends Visitor {
-  final Scope scope;
   final Queue parents = new Queue();
 
-  ObserverBuilder(this.scope);
+  ObserverBuilder();
 
   visitEmptyExpression(EmptyExpression e) => new EmptyObserver(e);
 
   visitParenthesizedExpression(ParenthesizedExpression e) => visit(e.child);
 
   visitGetter(Getter g) {
     var receiver = visit(g.receiver);
     var getter = new GetterObserver(g, receiver);
     receiver._parent = getter;
     return getter;
@@ skipping 67 matching lines @@
     var trueExpr = visit(o.trueExpr);
     var falseExpr = visit(o.falseExpr);
     var ternary = new TernaryObserver(o, condition, trueExpr, falseExpr);
     condition._parent = ternary;
     trueExpr._parent = ternary;
     falseExpr._parent = ternary;
     return ternary;
   }
 
   visitInExpression(InExpression i) {
-    // don't visit the left. It's an identifier, but we don't want to evaluate
-    // it, we just want to add it to the comprehension object
-    var left = visit(i.left);
-    var right = visit(i.right);
-    var inexpr = new InObserver(i, left, right);
-    right._parent = inexpr;
-    return inexpr;
+    throw new UnsupportedError("can't eval an 'in' expression");
+  }
+
+  visitAsExpression(AsExpression i) {
+    throw new UnsupportedError("can't eval an 'as' expression");
   }
 }
 
 class EmptyObserver extends ExpressionObserver<EmptyExpression>
     implements EmptyExpression {
 
   EmptyObserver(EmptyExpression value) : super(value);
 
   _updateSelf(Scope scope) {
     _value = scope.model;
@@ skipping 257 matching lines @@
                 _invalidate(scope);
               }
             });
       }
     }
   }
 
   accept(Visitor v) => v.visitInvoke(this);
 }
 
-class InObserver extends ExpressionObserver<InExpression>
-    implements InExpression {
-  IdentifierObserver left;
-  ExpressionObserver right;
-
-  InObserver(Expression expr, this.left, this.right) : super(expr);
-
-  _updateSelf(Scope scope) {
-    Identifier identifier = left;
-    var iterable = right._value;
-
-    if (iterable is! Iterable && iterable != null) {
-      throw new EvalException("right side of 'in' is not an iterator");
-    }
-
-    if (iterable is ObservableList) {
-      _subscription = iterable.listChanges.listen((_) => _invalidate(scope));
-    }
-
-    // TODO: make Comprehension observable and update it
-    _value = new Comprehension(identifier.value, iterable);
-  }
-
-  accept(Visitor v) => v.visitInExpression(this);
-}
 
 _toBool(v) => (v == null) ? false : v;
 
-/**
- * A comprehension declaration ("a in b"). [identifier] is the loop variable
- * that's added to the scope during iteration. [iterable] is the set of
- * objects to iterate over.
- */
-class Comprehension {
-  final String identifier;
-  final Iterable iterable;
-
-  Comprehension(this.identifier, Iterable iterable)
-      : iterable = (iterable != null) ? iterable : const [];
-}
-
 class EvalException implements Exception {
   final String message;
   EvalException(this.message);
   String toString() => "EvalException: $message";
 }