Ternary operator support for polymer_expressions

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 ['+', '-', '!'];
@@ skipping 48 matching lines @@
           left = _astFactory.index(left, indexExpr);
         } else {
           break;
         }
       } else if (_token.kind == DOT_TOKEN) {
         _advance();
         var right = _parseUnary();
         left = _makeInvokeOrGetter(left, right);
       } else if (_token.kind == KEYWORD_TOKEN && _token.value == 'in') {
         left = _parseComprehension(left);
+      } else if (_token.kind == OPERATOR_TOKEN && _token.value == '?') {
+        left = _parseTernary(left);
       } else if (_token.kind == OPERATOR_TOKEN
           && _token.precedence >= precedence) {
         left = _parseBinary(left);
       } else {
         break;
       }
     }
     return left;
   }
 
@@ skipping 38 matching lines @@
         }
       } else if (value == '!') {
         _advance();
         var expr = _parsePrecedence(_parsePrimary(), POSTFIX_PRECEDENCE);
         return _astFactory.unary(value, expr);
       }
     }
     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 (keyword == 'in') {
           return null;
         }
         throw new ArgumentError('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();
         }
         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 ":"');
       default:
         return null;
     }
   }
 
   MapLiteral _parseMapLiteral() {
     var entries = [];
     do {
       _advance();
       if (_token.kind == GROUPER_TOKEN && _token.value == '}') {
@@ skipping 100 matching lines @@
     return value;
   }
 
   Literal<double> _parseDecimal([String prefix = '']) {
     var value = _astFactory.literal(double.parse('$prefix${_token.value}'));
     _advance();
     return value;
   }
 
 }