Split out Index AST node from Invoke

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';
 
 @MirrorsUsed(metaTargets: const [Reflectable, ObservableProperty],
@@ skipping 64 matching lines @@
   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.

[Jennifer Messerly, 2013/11/18 20:28:41]

out of curiosity, why have the restriction that the index must be literal? is it
just not implemented?

[justinfagnani, 2013/11/20 03:50:33]

No, I was just being conservative at the time and wanted to make sure that we
knew which object we were assigning too. Some cases, like f(a) and (a + 2) are
clearly not assignable, while f(a).name might be. This simplest restriction I
could come up with property paths, but supporting a.b[3].c seemed very useful
not far from property paths. The more general restriction is that we need to be
able to separate the expression into the owner and the property and right not
the property must be a name or constant index value. We can relax this so that
the property can be an expression that's evaluated and then as long as we can
separate the expression, it's assignable. f(a) still wouldn't work, but
f(a).name would, and a[b].

[Jennifer Messerly, 2013/11/20 04:04:56]

makes sense. yeah, I think we'd eventually want all lvalues to be supported,
where lvalue is either:

name  (variable)
expr.name (property access)
expr[expr] (indexing)

  */
 void assign(Expression expr, Object value, Scope scope) {
 
   notAssignable() =>
       throw new EvalException("Expression is not assignable: $expr");
 
   Expression expression;
   var property;
   bool isIndex = false;
   var filters = <Expression>[]; // reversed order for assignment
 
   while (expr is BinaryOperator) {
     BinaryOperator op = expr;
     if (op.operator != '|') {
       break;
     }
     filters.add(op.right);
     expr = op.left;
   }
 
   if (expr is Identifier) {
     expression = empty();
     Identifier ident = expr;
     property = ident.value;
+  } else if (expr is Index) {
+    if (expr.argument is! Literal) notAssignable();
+    expression = expr.receiver;
+    Literal l = expr.argument;
+    property = l.value;
+    isIndex = true;
+  } else if (expr is Getter) {
+    expression = expr.receiver;
+    property = expr.name;
   } else if (expr is Invoke) {
-    Invoke invoke = expr;
-    expression = invoke.receiver;
-    if (invoke.method == '[]') {
-      if (invoke.arguments[0] is! Literal) notAssignable();
-      Literal l = invoke.arguments[0];
-      property = l.value;
-      isIndex = true;
-    } else if (invoke.method != null) {
-      if (invoke.arguments != null) notAssignable();
-      property = invoke.method;
+    expression = expr.receiver;
+    if (expr.method != null) {
+      if (expr.arguments != null) notAssignable();
+      property = expr.method;
     } else {
       notAssignable();
     }
   } else {
     notAssignable();
   }
 
   // transform the values backwards through the filters
   for (var filterExpr in filters) {
     var filter = eval(filterExpr, scope);
@@ skipping 20 matching lines @@
  * Scopes can be nested by giving them a [parent]. If a name in not found in a
  * Scope, it will look for it in it's parent.
  */
 class Scope {
   final Scope parent;
   final Object model;
   // TODO(justinfagnani): disallow adding/removing names
   final ObservableMap<String, Object> _variables;
   InstanceMirror __modelMirror;
 
-  Scope({this.model, Map<String, Object> variables: const {}, this.parent})
-      : _variables = new ObservableMap.from(variables);
+  Scope({this.model, Map<String, Object> variables, this.parent})
+      : _variables = new ObservableMap.from(variables == null ? {} : variables);
 
   InstanceMirror get _modelMirror {
     if (__modelMirror != null) return __modelMirror;
     __modelMirror = reflect(model);
     return __modelMirror;
   }
 
   Object operator[](String name) {
     if (name == 'this') {
       return model;
@@ skipping 124 matching lines @@
 class ObserverBuilder extends Visitor {
   final Scope scope;
   final Queue parents = new Queue();
 
   ObserverBuilder(this.scope);
 
   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;
+  }
+
+  visitIndex(Index i) {
+    var receiver = visit(i.receiver);
+    var arg = visit(i.argument);
+    var index =  new IndexObserver(i, receiver, arg);
+    receiver._parent = index;
+    arg._parent = index;
+    return index;
+  }
+
   visitInvoke(Invoke i) {
     var receiver = visit(i.receiver);
     var args = (i.arguments == null)
         ? null
         : i.arguments.map(visit).toList(growable: false);
     var invoke =  new InvokeObserver(i, receiver, args);
     receiver._parent = invoke;
     if (args != null) args.forEach((a) => a._parent = invoke);
     return invoke;
   }
@@ skipping 182 matching lines @@
             .listen((_) => _invalidate(scope));
       }
       _value = f(left._value, right._value);
     }
   }
 
   accept(Visitor v) => v.visitBinaryOperator(this);
 
 }
 
+class GetterObserver extends ExpressionObserver<Getter> implements Getter {
+  final ExpressionObserver receiver;
+
+  GetterObserver(Expression expr, this.receiver) : super(expr);
+
+  String get name => _expr.name;
+
+  _updateSelf(Scope scope) {
+    var receiverValue = receiver._value;
+    if (receiverValue == null) {
+      _value = null;
+      return;
+    }
+    var mirror = reflect(receiverValue);
+    var symbol = new Symbol(_expr.name);
+    _value = mirror.getField(symbol).reflectee;
+
+    if (receiverValue is Observable) {
+      _subscription = (receiverValue as Observable).changes.listen((changes) {
+        if (changes.any((c) => c is PropertyChangeRecord && c.name == symbol)) {
+          _invalidate(scope);
+        }
+      });
+    }
+  }
+
+  accept(Visitor v) => v.visitGetter(this);
+}
+
+class IndexObserver extends ExpressionObserver<Index> implements Index {
+  final ExpressionObserver receiver;
+  final ExpressionObserver argument;
+
+  IndexObserver(Expression expr, this.receiver, this.argument) : super(expr);
+
+  _updateSelf(Scope scope) {
+    var receiverValue = receiver._value;
+    if (receiverValue == null) {
+      _value = null;
+      return;
+    }
+    var key = argument._value;
+    _value = receiverValue[key];
+
+    if (receiverValue is Observable) {
+      _subscription = (receiverValue as Observable).changes.listen((changes) {
+        if (changes.any((c) => c is MapChangeRecord && c.key == key)) {
+          _invalidate(scope);
+        }
+      });
+    }
+  }
+
+  accept(Visitor v) => v.visitIndex(this);
+}
+
 class InvokeObserver extends ExpressionObserver<Invoke> implements Invoke {
   final ExpressionObserver receiver;
-  List<ExpressionObserver> arguments;
+  final List<ExpressionObserver> arguments;
 
-  InvokeObserver(Expression expr, this.receiver, [this.arguments])
-      : super(expr);
-
-  bool get isGetter => _expr.isGetter;
+  InvokeObserver(Expression expr, this.receiver, this.arguments)
+      : super(expr) {
+    assert(arguments != null);
+  }
 
   String get method => _expr.method;
 
   _updateSelf(Scope scope) {
-    var args = (arguments == null)
-        ? []
-        : arguments.map((a) => a._value)
-            .toList(growable: false);
+    var args = arguments.map((a) => a._value).toList();
     var receiverValue = receiver._value;
     if (receiverValue == null) {
       _value = null;
-    } else if (_expr.method == null) {
-      if (_expr.isGetter) {
-        // getter, but not a top-level identifier
-        // TODO(justin): listen to the receiver's owner
-        _value = receiverValue;
-      } else {
-        // top-level function or model method
-        // TODO(justin): listen to model changes to see if the method has
-        // changed? listen to the scope to see if the top-level method has
-        // changed?
-        assert(receiverValue is Function);
-        _value = call(receiverValue, args);
-      }
+      return;
+    }
+    if (_expr.method == null) {
+      // top-level function or model method
+      // TODO(justin): listen to model changes to see if the method has
+      // changed? listen to the scope to see if the top-level method has
+      // changed?
+      assert(receiverValue is Function);
+      _value = call(receiverValue, args);
     } else {
-      // special case [] because we don't need mirrors
-      if (_expr.method == '[]') {
-        assert(args.length == 1);
-        var key = args[0];
-        _value = receiverValue[key];
+      var mirror = reflect(receiverValue);
+      var symbol = new Symbol(_expr.method);
+      _value = mirror.invoke(symbol, args, null).reflectee;
 
-        if (receiverValue is Observable) {
-          _subscription = (receiverValue as Observable).changes.listen(
-              (List<ChangeRecord> changes) {
-                if (changes.any((c) =>
-                    c is MapChangeRecord && c.key == key)) {
-                  _invalidate(scope);
-                }
-              });
-        }
-      } else {
-        var mirror = reflect(receiverValue);
-        var symbol = new Symbol(_expr.method);
-        _value = (_expr.isGetter)
-            ? mirror.getField(symbol).reflectee
-            : mirror.invoke(symbol, args, null).reflectee;
-
-        if (receiverValue is Observable) {
-          _subscription = (receiverValue as Observable).changes.listen(
-              (List<ChangeRecord> changes) {
-                if (changes.any(
-                    (c) => c is PropertyChangeRecord && c.name == symbol)) {
-                  _invalidate(scope);
-                }
-              });
-        }
+      if (receiverValue is Observable) {
+        _subscription = (receiverValue as Observable).changes.listen(
+            (List<ChangeRecord> changes) {
+              if (changes.any(
+                  (c) => c is PropertyChangeRecord && c.name == symbol)) {
+                _invalidate(scope);
+              }
+            });
       }
     }
   }
 
   accept(Visitor v) => v.visitInvoke(this);
 }
 
 class InObserver extends ExpressionObserver<InExpression>
     implements InExpression {
   IdentifierObserver left;
@@ skipping 61 matching lines @@
    * This does not work for calls that need to pass more than one argument.
    */
   call(arg0) => mirror.invoke(symbol, [arg0], null).reflectee;
 }
 
 class EvalException implements Exception {
   final String message;
   EvalException(this.message);
   String toString() => "EvalException: $message";
 }