Use const instead of runtime type for equality of EmptyExpression.

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() => new EmptyExpression();
+EmptyExpression empty() => const EmptyExpression();
 Literal literal(v) => new Literal(v);
 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);
 Invoke invoke(Expression e, String m, [List<Expression> a]) =>
     new Invoke(e, m, a);
 InExpression inExpr(Expression l, Expression r) => new InExpression(l, r);
 
 
 class AstFactory {
-  EmptyExpression empty() => new EmptyExpression();
+  EmptyExpression empty() => const EmptyExpression();
 
   Literal literal(v) => new Literal(v);
 
   MapLiteral mapLiteral(List<MapLiteralEntry> entries) =>
       new MapLiteral(entries);
 
   MapLiteralEntry mapLiteralEntry(Literal key, Expression value) =>
       new MapLiteralEntry(key, value);
 
   Identifier identifier(String v) => new Identifier(v);
 
   ParenthesizedExpression parenthesized(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);
 
   Invoke invoke(Expression e, String m, [List<Expression> a]) =>
       new Invoke(e, m, a);
 
   InExpression inExpr(Expression l, Expression r) => new InExpression(l, r);
 }
 
 /// Base class for all expressions
 abstract class Expression {
+  const Expression();
   accept(Visitor v);
 }
 
 class EmptyExpression extends Expression {
+  const EmptyExpression();
   accept(Visitor v) => v.visitEmptyExpression(this);
-  bool operator ==(o) => o is EmptyExpression;
 }
 
 class Literal<T> extends Expression {
   final T value;
 
   Literal(this.value);
 
   accept(Visitor v) => v.visitLiteral(this);
 
   String toString() => (value is String) ? '"$value"' : '$value';
@@ skipping 171 matching lines @@
     return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
   }
 
   static int hash2(a, b) => finish(combine(combine(0, a), b));
 
   static int hash3(a, b, c) => finish(combine(combine(combine(0, a), b), c));
 
   static int hash4(a, b, c, d) =>
       finish(combine(combine(combine(combine(0, a), b), c), d));
 }