Split out Index AST node from Invoke

pkg/polymer_expressions/test/parser_test.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 parser_test;
 
 import 'package:polymer_expressions/parser.dart';
 import 'package:polymer_expressions/expression.dart';
 import 'package:unittest/unittest.dart';
 
@@ skipping 62 matching lines @@
 
     test('should give multiply higher associativity than plus 2', () {
       expectParse('a * b + c',
           binary(
               binary(ident('a'), '*', ident('b')),
               '+',
               ident('c')));
     });
 
     test('should parse a dot operator', () {
-      expectParse('a.b', invoke(ident('a'), 'b'));
+      expectParse('a.b', getter(ident('a'), 'b'));
     });
 
     test('should parse chained dot operators', () {
-      expectParse('a.b.c', invoke(invoke(ident('a'), 'b'), 'c'));
+      expectParse('a.b.c', getter(getter(ident('a'), 'b'), 'c'));
     });
 
     test('should give dot high associativity', () {
-      expectParse('a * b.c', binary(ident('a'), '*', invoke(ident('b'), 'c')));
+      expectParse('a * b.c', binary(ident('a'), '*', getter(ident('b'), 'c')));
     });
 
     test('should parse a function with no arguments', () {
       expectParse('a()', invoke(ident('a'), null, []));
     });
 
     test('should parse a single function argument', () {
       expectParse('a(b)', invoke(ident('a'), null, [ident('b')]));
     });
 
@@ skipping 37 matching lines @@
     });
 
     test('should parse parenthesized expression', () {
       expectParse('(a)', paren(ident('a')));
       expectParse('(( 3 * ((1 + 2)) ))', paren(paren(
           binary(literal(3), '*', paren(paren(
               binary(literal(1), '+', literal(2))))))));
     });
 
     test('should parse an index operator', () {
-      expectParse('a[b]', invoke(ident('a'), '[]', [ident('b')]));
-      expectParse('a.b[c]', invoke(invoke(ident('a'), 'b', null),
-          '[]', [ident('c')]));
+      expectParse('a[b]', index(ident('a'), ident('b')));
+      expectParse('a.b[c]', index(getter(ident('a'), 'b'), ident('c')));
     });
 
     test('should parse chained index operators', () {
-      expectParse('a[][]', invoke(invoke(ident('a'), '[]', []), '[]', []));
+      expectParse('a[][]', index(index(ident('a'), null), null));
     });
 
     test('should parse multiple index operators', () {
       expectParse('a[b] + c[d]', binary(
-          invoke(ident('a'), '[]', [ident('b')]),
+          index(ident('a'), ident('b')),
           '+',
-          invoke(ident('c'), '[]', [ident('d')])));
+          index(ident('c'), ident('d'))));
     });
 
     test('should parse a filter chain', () {
       expectParse('a | b | c', binary(binary(ident('a'), '|', ident('b')),
           '|', ident('c')));
     });
 
     test('should parse comprehension', () {
       expectParse('a in b', inExpr(ident('a'), ident('b')));
       expectParse('a in b.c',
-          inExpr(ident('a'), invoke(ident('b'), 'c', null)));
+          inExpr(ident('a'), getter(ident('b'), 'c')));
       expectParse('a in b + c',
           inExpr(ident('a'), binary(ident('b'), '+', ident('c'))));
     });
 
     test('should reject comprehension with non-assignable left expression', () {
       expect(() => parse('a + 1 in b'), throwsException);
     });
 
     test('should reject keywords as identifiers', () {
       expect(() => parse('a.in'), throwsException);
@@ skipping 10 matching lines @@
       expectParse("{'a': foo()}",
           mapLiteral([mapLiteralEntry(
               literal('a'), invoke(ident('foo'), null, []))]));
       expectParse("{'a': foo('a')}",
           mapLiteral([mapLiteralEntry(
               literal('a'), invoke(ident('foo'), null, [literal('a')]))]));
     });
 
     test('should parse map literals with method calls', () {
       expectParse("{'a': 1}.length",
-          invoke(mapLiteral([mapLiteralEntry(literal('a'), literal(1))]),
+          getter(mapLiteral([mapLiteralEntry(literal('a'), literal(1))]),
               'length'));
     });
   });
 }