merge to trunk all changes from 36817 until 37378 under the packages: polymer,

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';
+export 'tokenizer.dart' show ParseException;
 import 'expression.dart';
 
-const _UNARY_OPERATORS = const ['+', '-', '!'];
+const _UNARY_OPERATORS = const <String>['+', '-', '!'];
+const _BINARY_OPERATORS = const <String>['+', '-', '*', '/', '%', '^', '==',
+    '!=', '>', '<', '>=', '<=', '||', '&&', '&', '===', '!==', '|'];
 
 Expression parse(String expr) => new Parser(expr).parse();
 
 class Parser {
   final AstFactory _astFactory;
   final Tokenizer _tokenizer;
   List<Token> _tokens;
   Iterator _iterator;
   Token get _token => _iterator.current;
 
@@ skipping 68 matching lines @@
     } 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;
+    if (!_BINARY_OPERATORS.contains(op.value)) {
+      throw new ParseException("unknown operator: ${op.value}");
+    }
     _advance();
     var right = _parseUnary();
     while (_token != null
         && (_token.kind == OPERATOR_TOKEN
         || _token.kind == DOT_TOKEN
         || _token.kind == GROUPER_TOKEN)
         && _token.precedence > op.precedence) {
       right = _parsePrecedence(right, _token.precedence);
     }
     return _astFactory.binary(left, op.value, right);
   }
 
   Expression _parseUnary() {
     if (_token.kind == OPERATOR_TOKEN) {
       var value = _token.value;
       if (value == '+' || value == '-') {
         _advance();
         if (_token.kind == INTEGER_TOKEN) {
           return _parseInteger(value);
         } else if (_token.kind == DECIMAL_TOKEN) {
           return _parseDecimal(value);
         } else {
           var expr = _parsePrecedence(_parsePrimary(), POSTFIX_PRECEDENCE);
           return _astFactory.unary(value, expr);
         }
       } else if (value == '!') {
         _advance();
         var expr = _parsePrecedence(_parsePrimary(), POSTFIX_PRECEDENCE);
         return _astFactory.unary(value, expr);
+      } else {
+        throw new ParseException("unexpected token: $value");
       }
     }
     return _parsePrimary();
   }
 
   Expression _parseTernary(condition) {
     _advance(OPERATOR_TOKEN, '?');
     var trueExpr = _parseExpression();
     _advance(COLON_TOKEN);
     var falseExpr = _parseExpression();
     return _astFactory.ternary(condition, trueExpr, falseExpr);
   }
 
   Expression _parsePrimary() {
     var kind = _token.kind;
     switch (kind) {
       case KEYWORD_TOKEN:
         var keyword = _token.value;
         if (keyword == 'this') {
           _advance();
           // TODO(justin): return keyword node
           return _astFactory.identifier('this');
         } else if (KEYWORDS.contains(keyword)) {
-          throw new ParseException('invalid keyword: $keyword');
+          throw new ParseException('unexpected keyword: $keyword');
         }
-        throw new ArgumentError('unrecognized keyword: $keyword');
+        throw new ParseException('unrecognized keyword: $keyword');
       case IDENTIFIER_TOKEN:
         return _parseInvokeOrIdentifier();
       case STRING_TOKEN:
         return _parseString();
       case INTEGER_TOKEN:
         return _parseInteger();
       case DECIMAL_TOKEN:
         return _parseDecimal();
       case GROUPER_TOKEN:
         if (_token.value == '(') {
           return _parseParenthesized();
         } else if (_token.value == '{') {
           return _parseMapLiteral();
         } else if (_token.value == '[') {
           return _parseListLiteral();
         }
         return null;
       case COLON_TOKEN:
-        // TODO(justinfagnani): We need better errors throughout the parser, and
-        // we should be throwing ParseErrors to be caught by the caller
-        throw new ArgumentError('unexpected token ":"');
+        throw new ParseException('unexpected token ":"');
       default:
         return null;
     }
   }
 
   ListLiteral _parseListLiteral() {
     var items = [];
     do {
       _advance();
       if (_token.kind == GROUPER_TOKEN && _token.value == ']') {
@@ skipping 35 matching lines @@
     var right = _parseExpression();
     return _astFactory.inExpr(left, right);
   }
 
   AsExpression _parseAsExpression(Expression left) {
     assert(_token.value == 'as');
     _advance();
     var right = _parseExpression();
     if (right is! Identifier) {
       throw new ParseException(
-          "as... statements must end with an identifier");
+          "'as' statements must end with an identifier");
     }
     return _astFactory.asExpr(left, right);
   }
 
   Expression _parseInvokeOrIdentifier() {
     if (_token.value == 'true') {
       _advance();
       return _astFactory.literal(true);
     }
     if (_token.value == 'false') {
@@ skipping 68 matching lines @@
     return value;
   }
 
   Literal<double> _parseDecimal([String prefix = '']) {
     var value = _astFactory.literal(double.parse('$prefix${_token.value}'));
     _advance();
     return value;
   }
 
 }