Implement 'as' operator.

lib/compiler/implementation/scanner/parser.dart

 // Copyright (c) 2012, 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.
 
 /**
  * An event generating parser of Dart programs. This parser expects
  * all tokens in a linked list (aka a token stream).
  *
  * The class [Scanner] is used to generate a token stream. See the
  * file scanner.dart.
@@ skipping 912 matching lines @@
             token = parseArgumentOrIndexStar(token);
           } else if ((info === PLUS_PLUS_INFO) ||
                      (info === MINUS_MINUS_INFO)) {
             listener.handleUnaryPostfixAssignmentExpression(token);
             token = token.next;
           } else {
             token = listener.unexpected(token);
           }
         } else if (info === IS_INFO) {
           token = parseIsOperatorRest(token);
+        } else if (info === AS_INFO) {
+          token = parseAsOperatorRest(token);
         } else if (info === QUESTION_INFO) {
           token = parseConditionalExpressionRest(token);
         } else {
           // Left associative, so we recurse at the next higher
           // precedence level.
           token = parsePrecedenceExpression(token.next, level + 1,
                                             withoutCascades);
           listener.handleBinaryExpression(operator);
         }
         info = token.info;
@@ skipping 406 matching lines @@
   Token parseIsOperatorRest(Token token) {
     assert(optional('is', token));
     Token operator = token;
     Token not = null;
     if (optional('!', token.next)) {
       token = token.next;
       not = token;
     }
     token = parseType(token.next);
     listener.handleIsOperator(operator, not, token);
-    if (optional('is', token)) {
-      // The is-operator cannot be chained, but it can take part of
+    if (optional('is', token) || optional('as', token)) {
+      // The is- and as-operators cannot be chained, but they can take part of
       // expressions like: foo is Foo || foo is Bar.
       listener.unexpected(token);
     }
     return token;
   }
 
+  Token parseAsOperatorRest(Token token) {
+    assert(optional('as', token));
+    Token operator = token;
+    token = parseType(token.next);
+    listener.handleAsOperator(operator, token);
+    if (optional('is', token) || optional('as', token)) {
+      // The is- and as-operators cannot be chained.
+      listener.unexpected(token);
+    }
+    return token;
+  }
+
   Token parseVariablesDeclaration(Token token) {
     token = parseVariablesDeclarationNoSemicolon(token);
     return expectSemicolon(token);
   }
 
   Token parseVariablesDeclarationNoSemicolon(Token token) {
     int count = 1;
     listener.beginVariablesDeclaration(token);
     token = parseModifiers(token);
     token = parseTypeOpt(token);
@@ skipping 294 matching lines @@
     }
     listener.handleContinueStatement(hasTarget, continueKeyword, token);
     return expectSemicolon(token);
   }
 
   Token parseEmptyStatement(Token token) {
     listener.handleEmptyStatement(token);
     return expectSemicolon(token);
   }
 }