Optimizes 'as' operation in similar way as 'instanceof': collect type feedback in unoptimized mode…

runtime/vm/flow_graph_optimizer.cc

 // 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.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
@@ skipping 1817 matching lines @@
       new InstanceOfInstr(call->token_pos(),
                           new Value(left),
                           new Value(instantiator),
                           new Value(type_args),
                           type,
                           negate);
   ReplaceCall(call, instance_of);
 }
 
 
+void FlowGraphOptimizer::ReplaceWithTypeCast(InstanceCallInstr* call) {
+  ASSERT(Token::IsTypeCastOperator(call->token_kind()));
+  Definition* left = call->ArgumentAt(0);
+  Definition* instantiator = call->ArgumentAt(1);
+  Definition* type_args = call->ArgumentAt(2);
+  const AbstractType& type =
+      AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value());
+  ASSERT(!type.IsMalformed());
+  const ICData& unary_checks =
+      ICData::ZoneHandle(call->ic_data()->AsUnaryClassChecks());
+  if (unary_checks.NumberOfChecks() <= FLAG_max_polymorphic_checks) {
+    Bool& as_bool = Bool::ZoneHandle(InstanceOfAsBool(unary_checks, type));
+    if (as_bool.raw() == Bool::True().raw()) {
+      AddReceiverCheck(call);
+      // Remove the original push arguments.
+      for (intptr_t i = 0; i < call->ArgumentCount(); ++i) {
+        PushArgumentInstr* push = call->PushArgumentAt(i);
+        push->ReplaceUsesWith(push->value()->definition());
+        push->RemoveFromGraph();
+      }
+      // Remove call, replace it with 'left'.
+      call->ReplaceUsesWith(left);
+      call->RemoveFromGraph();
+      return;
+    }
+  }
+  const String& dst_name = String::ZoneHandle(
+      Symbols::New(Exceptions::kCastErrorDstName));
+  AssertAssignableInstr* assert_as =
+      new AssertAssignableInstr(call->token_pos(),
+                                new Value(left),
+                                new Value(instantiator),
+                                new Value(type_args),
+                                type,
+                                dst_name);
+  ReplaceCall(call, assert_as);
+}
+
+
 // Tries to optimize instance call by replacing it with a faster instruction
 // (e.g, binary op, field load, ..).
 void FlowGraphOptimizer::VisitInstanceCall(InstanceCallInstr* instr) {
   if (!instr->HasICData() || (instr->ic_data()->NumberOfChecks() == 0)) {
     return;
   }
 
   const Token::Kind op_kind = instr->token_kind();
   // Type test is special as it always gets converted into inlined code.
   if (Token::IsTypeTestOperator(op_kind)) {
     ReplaceWithInstanceOf(instr);
     return;
   }
 
+  if (Token::IsTypeCastOperator(op_kind)) {
+    ReplaceWithTypeCast(instr);
+    return;
+  }
+
   const ICData& unary_checks =
       ICData::ZoneHandle(instr->ic_data()->AsUnaryClassChecks());
 
   if ((unary_checks.NumberOfChecks() > FLAG_max_polymorphic_checks) &&
       InstanceCallNeedsClassCheck(instr)) {
     // Too many checks, it will be megamorphic which needs unary checks.
     instr->set_ic_data(&unary_checks);
     return;
   }
 
@@ skipping 2763 matching lines @@
   if (changed) {
     // We may have changed the block order and the dominator tree.
     flow_graph->DiscoverBlocks();
     GrowableArray<BitVector*> dominance_frontier;
     flow_graph->ComputeDominators(&dominance_frontier);
   }
 }
 
 
 }  // namespace dart