Refactor of PolymerExpressions. Adds "as" expressions.

pkg/polymer_expressions/lib/expression.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.expression;
 
 import 'visitor.dart';
 
 // Helper functions for building expression trees programmatically
 
 EmptyExpression empty() => const EmptyExpression();
 Literal literal(v) => new Literal(v);
 ListLiteral listLiteral(List<Expression> items) => new ListLiteral(items);
 MapLiteral mapLiteral(List<MapLiteralEntry> entries) => new MapLiteral(entries);
 MapLiteralEntry mapLiteralEntry(Literal key, Expression value) =>
     new MapLiteralEntry(key, value);
 Identifier ident(String v) => new Identifier(v);
 ParenthesizedExpression paren(Expression e) => new ParenthesizedExpression(e);
 UnaryOperator unary(String op, Expression e) => new UnaryOperator(op, e);
 BinaryOperator binary(Expression l, String op, Expression r) =>
     new BinaryOperator(l, op, r);
 Getter getter(Expression e, String m) => new Getter(e, m);
 Index index(Expression e, Expression a) => new Index(e, a);
 Invoke invoke(Expression e, String m, List<Expression> a) =>
     new Invoke(e, m, a);
 InExpression inExpr(Expression l, Expression r) => new InExpression(l, r);
+AsExpression asExpr(Expression l, Expression r) => new AsExpression(l, r);
 TernaryOperator ternary(Expression c, Expression t, Expression f) =>
     new TernaryOperator(c, t, f);
 
 class AstFactory {
   EmptyExpression empty() => const EmptyExpression();
 
   Literal literal(v) => new Literal(v);
 
   MapLiteral mapLiteral(List<MapLiteralEntry> entries) =>
       new MapLiteral(entries);
@@ skipping 15 matching lines @@
       new TernaryOperator(c, t, f);
 
   Getter getter(Expression g, String n) => new Getter(g, n);
 
   Index index(Expression e, Expression a) => new Index(e, a);
 
   Invoke invoke(Expression e, String m, List<Expression> a) =>
       new Invoke(e, m, a);
 
   InExpression inExpr(Expression l, Expression r) => new InExpression(l, r);
+
+  AsExpression asExpr(Expression l, Expression r) => new AsExpression(l, r);
 }
 
 /// Base class for all expressions
 abstract class Expression {
   const Expression();
   accept(Visitor v);
 }
 
+abstract class HasIdentifier {
+  String get identifier;
+  Expression get expr;
+}
+
 class EmptyExpression extends Expression {
   const EmptyExpression();
   accept(Visitor v) => v.visitEmptyExpression(this);
 }
 
 class Literal<T> extends Expression {
   final T value;
 
   Literal(this.value);
 
@@ skipping 125 matching lines @@
 
   bool operator ==(o) => o is TernaryOperator
       && o.condition == condition
       && o.trueExpr == trueExpr
       && o.falseExpr == falseExpr;
 
   int get hashCode => _JenkinsSmiHash.hash3(condition.hashCode,
       trueExpr.hashCode, falseExpr.hashCode);
 }
 
-class InExpression extends Expression {
-  final Expression left;
+class InExpression extends Expression implements HasIdentifier {
+  final Identifier left;
   final Expression right;
 
   InExpression(this.left, this.right);
 
   accept(Visitor v) => v.visitInExpression(this);
 
+  String get identifier => left.value;
+
+  Expression get expr => right;
+
   String toString() => '($left in $right)';
 
   bool operator ==(o) => o is InExpression && o.left == left
       && o.right == right;
 
   int get hashCode => _JenkinsSmiHash.hash2(left.hashCode, right.hashCode);
 }
 
+class AsExpression extends Expression implements HasIdentifier {
+  final Expression left;
+  final Identifier right;
+
+  AsExpression(this.left, this.right);
+
+  accept(Visitor v) => v.visitAsExpression(this);
+
+  String get identifier => right.value;
+
+  Expression get expr => left;
+
+  String toString() => '($left as $right)';
+
+  bool operator ==(o) => o is AsExpression && o.left == left
+      && o.right == right;
+
+  int get hashCode => _JenkinsSmiHash.hash2(left.hashCode, right.hashCode);
+}
+
 class Index extends Expression {
   final Expression receiver;
   final Expression argument;
 
   Index(this.receiver, this.argument);
 
   accept(Visitor v) => v.visitIndex(this);
 
   String toString() => '$receiver[$argument]';
 
@@ skipping 86 matching lines @@
   }
 
   static int hash2(int a, int b) => finish(combine(combine(0, a), b));
 
   static int hash3(int a, int b, int c) =>
       finish(combine(combine(combine(0, a), b), c));
 
   static int hash4(int a, int b, int c, int d) =>
       finish(combine(combine(combine(combine(0, a), b), c), d));
 }