Split out Index AST node from Invoke

pkg/polymer_expressions/lib/parser.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.parser;
 
 import 'tokenizer.dart';
 import 'expression.dart';
 
 const _UNARY_OPERATORS = const ['+', '-', '!'];
 
 Expression parse(String expr) => new Parser(expr).parse();
 
 class Parser {
   final AstFactory _astFactory;
   final Tokenizer _tokenizer;
   List<Token> _tokens;
   Iterator _iterator;
-  Token _token;
+  Token get _token => _iterator.current;
 
   Parser(String input, {AstFactory astFactory})
       : _tokenizer = new Tokenizer(input),
         _astFactory = (astFactory == null) ? new AstFactory() : astFactory;
 
   Expression parse() {
     _tokens = _tokenizer.tokenize();
     _iterator = _tokens.iterator;
     _advance();
     return _parseExpression();
   }
 
   _advance([int kind, String value]) {
     if ((kind != null && _token.kind != kind)
         || (value != null && _token.value != value)) {
       throw new ParseException("Expected $value: $_token");
     }
-    _token = _iterator.moveNext() ? _iterator.current : null;
+    _iterator.moveNext();
   }
 
   Expression _parseExpression() {
     if (_token == null) return _astFactory.empty();
     var expr = _parseUnary();
     return (expr == null) ? null : _parsePrecedence(expr, 0);
   }
 
   // _parsePrecedence and _parseBinary implement the precedence climbing
   // algorithm as described in:
   // http://en.wikipedia.org/wiki/Operator-precedence_parser#Precedence_climbing_method
   Expression _parsePrecedence(Expression left, int precedence) {
     assert(left != null);
     while (_token != null) {
       if (_token.kind == GROUPER_TOKEN) {
         if (_token.value == '(') {
           var args = _parseArguments();
+          assert(args != null);
           left = _astFactory.invoke(left, null, args);
         } else if (_token.value == '[') {
           var indexExpr = _parseIndex();
-          var args = indexExpr == null ? [] : [indexExpr];
-          left = _astFactory.invoke(left, '[]', args);
+          left = _astFactory.index(left, indexExpr);
         } else {
           break;
         }
       } else if (_token.kind == DOT_TOKEN) {
         _advance();
         var right = _parseUnary();
-        left = _makeInvoke(left, right);
+        left = _makeInvokeOrGetter(left, right);
       } else if (_token.kind == KEYWORD_TOKEN && _token.value == 'in') {
         left = _parseComprehension(left);
       } else if (_token.kind == OPERATOR_TOKEN
           && _token.precedence >= precedence) {
         left = _parseBinary(left);
       } else {
         break;
       }
     }
     return left;
   }
 
-  Invoke _makeInvoke(left, right) {
+  // invoke or getter
+  Expression _makeInvokeOrGetter(left, right) {
     if (right is Identifier) {
-      return _astFactory.invoke(left, right.value);
+      return _astFactory.getter(left, right.value);
     } else if (right is Invoke && right.receiver is Identifier) {
       Identifier method = right.receiver;
       return _astFactory.invoke(left, method.value, right.arguments);
     } else {
       throw new ParseException("expected identifier: $right");
     }
   }
 
   Expression _parseBinary(left) {
     var op = _token;
@@ skipping 110 matching lines @@
     }
     var identifier = _parseIdentifier();
     var args = _parseArguments();
     if (args == null) {
       return identifier;
     } else {
       return _astFactory.invoke(identifier, null, args);
     }
   }
 
-  Invoke _parseInvoke() {
-    var identifier = _parseIdentifier();
-    var args = _parseArguments();
-    return _astFactory.invoke(null, identifier, args);
-  }
-
   Identifier _parseIdentifier() {
     if (_token.kind != IDENTIFIER_TOKEN) {
       throw new ParseException("expected identifier: $_token.value");
     }
     var value = _token.value;
     _advance();
     return _astFactory.identifier(value);
   }
 
   List<Expression> _parseArguments() {
@@ skipping 42 matching lines @@
     return value;
   }
 
   Literal<double> _parseDecimal([String prefix = '']) {
     var value = _astFactory.literal(double.parse('$prefix${_token.value}'));
     _advance();
     return value;
   }
 
 }