List literals in polymer_expressions

pkg/polymer_expressions/lib/eval.dart

Index: pkg/polymer_expressions/lib/eval.dart
diff --git a/pkg/polymer_expressions/lib/eval.dart b/pkg/polymer_expressions/lib/eval.dart
index c931096cf87e9e993864a2d3b2ae107fdb263e1f..be2fdec6245a73779b9a518331d8852be6c583db 100644
--- a/pkg/polymer_expressions/lib/eval.dart
+++ b/pkg/polymer_expressions/lib/eval.dart
@@ -336,6 +336,13 @@ class ObserverBuilder extends Visitor {
 
   visitLiteral(Literal l) => new LiteralObserver(l);
 
+  visitListLiteral(ListLiteral l) {
+    var items = l.items.map(visit).toList(growable: false);
+    var list = new ListLiteralObserver(l, items);
+    items.forEach((e) => e._parent = list);

[Jennifer Messerly, 2014/01/28 00:07:04]

thought for future refactoring ... it might be more consistent to move the
_parent logic to the constructor for the various types. That way the correct
parent relationship is guaranteed after construction.

I wouldn't do it in this CL though since it would affect all of the visit*
methods :)

[justinfagnani, 2014/01/28 02:16:21]

Agreed. I actually want to get rid of the observer wrappers all together, which
I think would force this to happen.

+    return list;
+  }
+
   visitMapLiteral(MapLiteral l) {
     var entries = l.entries.map(visit).toList(growable: false);
     var map = new MapLiteralObserver(l, entries);
@@ -418,6 +425,20 @@ class LiteralObserver extends ExpressionObserver<Literal> implements Literal {
   accept(Visitor v) => v.visitLiteral(this);
 }
 
+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);
+  }
+
+  accept(Visitor v) => v.visitListLiteral(this);
+}
+
 class MapLiteralObserver extends ExpressionObserver<MapLiteral>
     implements MapLiteral {