Don’t throw on assignments to non-assignable expressions. Allow non-literal indices in assignable e…

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 63 matching lines @@
 }
 
 /**
  * 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.
  */
-Object assign(Expression expr, Object value, Scope scope) {
-
-  notAssignable() =>
-      throw new EvalException("Expression is not assignable: $expr");
+Object assign(Expression expr, Object value, Scope scope,
+    {bool checkAssignability: true}) {
 
   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;
+    property = expr.value;
   } else if (expr is Index) {
-    if (expr.argument is! Literal) notAssignable();
     expression = expr.receiver;
-    Literal l = expr.argument;
-    property = l.value;
+    property = expr.argument;
     isIndex = true;
   } else if (expr is Getter) {
     expression = expr.receiver;
     property = expr.name;
-  } else if (expr is Invoke) {
-    expression = expr.receiver;
-    if (expr.method != null) {
-      if (expr.arguments != null) notAssignable();
-      property = expr.method;
-    } else {
-      notAssignable();
+  } else {
+    if (checkAssignability) {
+      throw new EvalException("Expression is not assignable: $expr");
     }
-  } else {
-    notAssignable();
+    return null;
   }
 
   // transform the values backwards through the filters
   for (var filterExpr in filters) {
     var filter = eval(filterExpr, scope);
     if (filter is! Transformer) {
-      throw new EvalException("filter must implement Transformer: $filterExpr");
+      if (checkAssignability) {
+        throw new EvalException("filter must implement Transformer to be "
+            "assignable: $filterExpr");
+      } else {
+        return null;
+      }
     }
     value = filter.reverse(value);
   }
-  // make the assignment
+  // evaluate the receiver
   var o = eval(expression, scope);
 
   // can't assign to a property on a null LHS object. Silently fail.
   if (o == null) return null;
 
   if (isIndex) {
-    o[property] = value;
+    var index = eval(property, scope);
+    o[index] = value;
   } else {
     smoke.write(o, smoke.nameToSymbol(property), value);
   }
   return value;
 }
 
 
 /**
  * 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
@@ skipping 564 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";
 }