Split out Index AST node from Invoke

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);
 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]) =>
+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);
 
 
 class AstFactory {
   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]) =>
+  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);
 }
 
 /// Base class for all expressions
 abstract class Expression {
   const Expression();
   accept(Visitor v);
 }
@@ skipping 118 matching lines @@
   accept(Visitor v) => v.visitInExpression(this);
 
   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 Index extends Expression {
+  final Expression receiver;
+  final Expression argument;
+
+  Index(this.receiver, this.argument);
+
+  accept(Visitor v) => v.visitIndex(this);
+
+  String toString() => '$receiver[$argument]';
+
+  bool operator ==(o) =>
+      o is Index
+      && o.receiver == receiver
+      && o.argument == argument;
+
+  int get hashCode =>
+      _JenkinsSmiHash.hash2(receiver.hashCode, argument.hashCode);
+}
+
+class Getter extends Expression {
+  final Expression receiver;
+  final String name;
+
+  Getter(this.receiver, this.name);
+
+  accept(Visitor v) => v.visitGetter(this);
+
+  String toString() => '$receiver.$name';
+
+  bool operator ==(o) =>
+      o is Getter
+      && o.receiver == receiver
+      && o.name == name;
+
+  int get hashCode => _JenkinsSmiHash.hash2(receiver.hashCode, name.hashCode);
+
+}
+
 /**
  * Represents a function or method invocation. If [method] is null, then
  * [receiver] is an expression that should evaluate to a function. If [method]
  * is not null, then [receiver] is an expression that should evaluate to an
  * object that has an appropriate method.
  */
 class Invoke extends Expression {
   final Expression receiver;
   final String method;
   final List<Expression> arguments;
 
-  Invoke(this.receiver, this.method, [this.arguments]);
+  Invoke(this.receiver, this.method, this.arguments) {
+    assert(arguments != null);
+  }
 
   accept(Visitor v) => v.visitInvoke(this);
 
-  bool get isGetter => arguments == null;
-
   String toString() => '$receiver.$method($arguments)';
 
   bool operator ==(o) =>
       o is Invoke
       && o.receiver == receiver
       && o.method == method
       && _listEquals(o.arguments, arguments);
 
   int get hashCode => _JenkinsSmiHash.hash3(receiver.hashCode, method.hashCode,
       _hashList(arguments));
@@ skipping 23 matching lines @@
     hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
     return hash ^ (hash >> 6);
   }
 
   static int finish(int hash) {
     hash = 0x1fffffff & (hash + ((0x03ffffff & hash) <<  3));
     hash = hash ^ (hash >> 11);
     return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
   }
 
-  static int hash2(a, b) => finish(combine(combine(0, a), b));
+  static int hash2(int a, int b) => finish(combine(combine(0, a), b));
 
-  static int hash3(a, b, c) => finish(combine(combine(combine(0, a), b), c));
+  static int hash3(int a, int b, int c) =>
+      finish(combine(combine(combine(0, a), b), c));
 
-  static int hash4(a, b, c, d) =>
+  static int hash4(int a, int b, int c, int d) =>
       finish(combine(combine(combine(combine(0, a), b), c), d));
 }