Refactor of PolymerExpressions. Adds "as" expressions.

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 46 matching lines @@
           '>=', '<=', '||', '&&', '&'];
       for (var op in operators) {
         expectParse('a $op b', binary(ident('a'), op, ident('b')));
         expectParse('1 $op 2', binary(literal(1), op, literal(2)));
         expectParse('this $op null', binary(ident('this'), op, literal(null)));
       }
     });
 
     test('should give multiply higher associativity than plus', () {
       expectParse('a + b * c',
-          binary(
-              ident('a'),
-              '+',
-              binary(ident('b'), '*', ident('c'))));
+          binary(ident('a'), '+', binary(ident('b'), '*', ident('c'))));
+      expectParse('a * b + c',
+          binary(binary(ident('a'), '*', ident('b')), '+', ident('c')));
     });
 
     test('should parse a dot operator', () {
       expectParse('a.b', getter(ident('a'), 'b'));
     });
 
     test('should parse chained dot operators', () {
       expectParse('a.b.c', getter(getter(ident('a'), 'b'), 'c'));
     });
 
@@ skipping 76 matching lines @@
       expectParse('a.a ? b.a : c.a', ternary(getter(ident('a'), 'a'),
           getter(ident('b'), 'a'), getter(ident('c'), 'a')));
       expect(() => parse('a + 1 ? b + 1 :: c.d + 3'), throws);
     });
 
     test('should parse a filter chain', () {
       expectParse('a | b | c', binary(binary(ident('a'), '|', ident('b')),
           '|', ident('c')));
     });
 
-    test('should parse comprehension', () {
+    test('should parse "in" expression', () {
       expectParse('a in b', inExpr(ident('a'), ident('b')));
       expectParse('a in b.c',
           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 parse "as" expressions', () {
+      expectParse('a as b', asExpr(ident('a'), ident('b')));
+    });
+
     test('should reject keywords as identifiers', () {
-      expect(() => parse('a.in'), throwsException);
+      expect(() => parse('a.in'), throws);
+      expect(() => parse('a.as'), throws);
+      // TODO: re-enable when 'this' is a keyword
+//      expect(() => parse('a.this'), throws);
     });
 
     test('should parse map literals', () {
       expectParse("{'a': 1}",
           mapLiteral([mapLiteralEntry(literal('a'), literal(1))]));
       expectParse("{'a': 1, 'b': 2 + 3}",
           mapLiteral([
               mapLiteralEntry(literal('a'), literal(1)),
               mapLiteralEntry(literal('b'),
                   binary(literal(2), '+', literal(3)))]));
@@ skipping 13 matching lines @@
 
     test('should parse list literals', () {
       expectParse('[1, "a", b]',
           listLiteral([literal(1), literal('a'), ident('b')]));
       expectParse('[[1, 2], [3, 4]]',
           listLiteral([listLiteral([literal(1), literal(2)]),
                        listLiteral([literal(3), literal(4)])]));
     });
   });
 }