Implement type cast in the VM.

runtime/vm/parser.cc

 // 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.
 
 #include "vm/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 5914 matching lines @@
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
       String::NewSymbol(error.ToErrorCString()))));
   return MakeStaticCall(kTypeErrorName, kThrowNewName, arguments);
 }
 
 
 AstNode* Parser::ParseBinaryExpr(int min_preced) {
   TRACE_PARSER("ParseBinaryExpr");
   ASSERT(min_preced >= 4);
   AstNode* left_operand = ParseUnaryExpr();
+  if (IsLiteral("as")) {  // Not a reserved word.
+    token_kind_ = Token::kAS;
+  }
   int current_preced = Token::Precedence(CurrentToken());
   while (current_preced >= min_preced) {
     while (Token::Precedence(CurrentToken()) == current_preced) {
       Token::Kind op_kind = CurrentToken();
       if (op_kind == Token::kTIGHTADD) {
         op_kind = Token::kADD;
       }
       const intptr_t op_pos = TokenPos();
       ConsumeToken();
       AstNode* right_operand = NULL;
-      if (op_kind != Token::kIS) {
+      if ((op_kind != Token::kIS) && (op_kind != Token::kAS)) {
         right_operand = ParseBinaryExpr(current_preced + 1);
       } else {
-        // For 'is' we expect the right operand to be a type.
-        if (CurrentToken() == Token::kNOT) {
+        // For 'is' and 'as' we expect the right operand to be a type.
+        if ((op_kind == Token::kIS) && (CurrentToken() == Token::kNOT)) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
         const intptr_t type_pos = TokenPos();
         const AbstractType& type =
             AbstractType::ZoneHandle(ParseType(ClassFinalizer::kFinalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureReceiver();
         }
         right_operand = new TypeNode(type_pos, type);
-        if (type.IsMalformed()) {
-          // Note that a type error is thrown even if the tested value is null.
+        if ((op_kind == Token::kIS) && type.IsMalformed()) {
+          // Note that a type error is thrown even if the tested value is null
+          // in a type test. However, no cast exception is thrown if the value
+          // is null in a type cast.
           return ThrowTypeError(type_pos, type);
         }
       }
       if (Token::IsRelationalOperator(op_kind)
-          || Token::IsInstanceofOperator(op_kind)
+          || Token::IsTypeTestOperator(op_kind)
+          || Token::IsTypeCastOperator(op_kind)
           || Token::IsEqualityOperator(op_kind)) {
-        if (Token::IsInstanceofOperator(op_kind)) {
+        if (Token::IsTypeTestOperator(op_kind) ||
+            Token::IsTypeCastOperator(op_kind)) {
           if (!right_operand->AsTypeNode()->type().IsInstantiated()) {
             EnsureExpressionTemp();
           }
         }
         left_operand = new ComparisonNode(
             op_pos, op_kind, left_operand, right_operand);
         break;  // Equality and relational operators cannot be chained.
       } else {
         left_operand = OptimizeBinaryOpNode(
             op_pos, op_kind, left_operand, right_operand);
@@ skipping 2629 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart