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

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 993 matching lines @@
 
 
 void EffectGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(node->kind()));
   EffectGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
 }
 
 
-void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
-  ASSERT(Token::IsTypeCastOperator(node->kind()));
-  const AbstractType& type = node->right()->AsTypeNode()->type();
-  ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
-  ValueGraphVisitor for_value(owner(), temp_index());
-  node->left()->Visit(&for_value);
-  const String& dst_name = String::ZoneHandle(
-      Symbols::New(Exceptions::kCastErrorDstName));
-  if (!CanSkipTypeCheck(node->token_pos(), for_value.value(), type, dst_name)) {
-    Append(for_value);
-    Do(BuildAssertAssignable(
-        node->token_pos(), for_value.value(), type, dst_name));
-  }
-}
-
-
 void ValueGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   const bool negate_result = (node->kind() == Token::kISNOT);
   // All objects are instances of type T if Object type is a subtype of type T.
   const Type& object_type = Type::Handle(Type::ObjectType());
   if (type.IsInstantiated() && object_type.IsSubtypeOf(type, NULL)) {
     // Must evaluate left side.
     EffectGraphVisitor for_left_value(owner(), temp_index());
@@ skipping 60 matching lines @@
   const Bool& negate = (node->kind() == Token::kISNOT) ? Bool::True() :
                                                          Bool::False();
   Value* negate_arg = Bind(new ConstantInstr(negate));
   arguments->Add(PushArgument(negate_arg));
   const intptr_t kNumArgsChecked = 1;
   InstanceCallInstr* call = new InstanceCallInstr(
       node->token_pos(),
       PrivateCoreLibName(Symbols::_instanceOf()),
       node->kind(),
       arguments,
-      Array::ZoneHandle(),
+      Array::ZoneHandle(),  // No argument names.
       kNumArgsChecked);
   ReturnDefinition(call);
 }
 
 
-void ValueGraphVisitor::BuildTypeCast(ComparisonNode* node) {
+void EffectGraphVisitor::BuildTypeCast(ComparisonNode* node) {
   ASSERT(Token::IsTypeCastOperator(node->kind()));
   const AbstractType& type = node->right()->AsTypeNode()->type();
   ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
   ValueGraphVisitor for_value(owner(), temp_index());
+  node->left()->Visit(&for_value);
+  const String& dst_name = String::ZoneHandle(
+      Symbols::New(Exceptions::kCastErrorDstName));
+  if (!CanSkipTypeCheck(node->token_pos(), for_value.value(), type, dst_name)) {
+    Append(for_value);
+    Do(BuildAssertAssignable(
+        node->token_pos(), for_value.value(), type, dst_name));
+  }
+}
+
+
+void ValueGraphVisitor::BuildTypeCast(ComparisonNode* node) {
+  ASSERT(Token::IsTypeCastOperator(node->kind()));
+  ASSERT(!node->right()->AsTypeNode()->type().IsNull());
+  const AbstractType& type = node->right()->AsTypeNode()->type();
+  ASSERT(type.IsFinalized());  // The type in a type cast may be malformed.
+  ValueGraphVisitor for_value(owner(), temp_index());
   node->left()->Visit(&for_value);
   Append(for_value);
   const String& dst_name = String::ZoneHandle(
       Symbols::New(Exceptions::kCastErrorDstName));
-  ReturnValue(BuildAssignableValue(node->token_pos(),
-                                   for_value.value(),
-                                   type,
-                                   dst_name));
+  if (type.IsMalformed()) {
+    ReturnValue(BuildAssignableValue(node->token_pos(),
+                                     for_value.value(),
+                                     type,
+                                     dst_name));
+  } else {
+    if (CanSkipTypeCheck(node->token_pos(),
+                         for_value.value(),
+                         type,
+                         dst_name)) {
+      ReturnValue(for_value.value());
+      return;
+    }
+    PushArgumentInstr* push_left = PushArgument(for_value.value());
+    PushArgumentInstr* push_instantiator = NULL;
+    PushArgumentInstr* push_type_args = NULL;
+    if (type.IsInstantiated()) {
+      push_instantiator = PushArgument(BuildNullValue());
+      push_type_args = PushArgument(BuildNullValue());
+    } else {
+      BuildTypecheckPushArguments(node->token_pos(),
+                                  &push_instantiator,
+                                  &push_type_args);
+    }
+    ZoneGrowableArray<PushArgumentInstr*>* arguments =
+        new ZoneGrowableArray<PushArgumentInstr*>(4);
+    arguments->Add(push_left);
+    arguments->Add(push_instantiator);
+    arguments->Add(push_type_args);
+    Value* type_arg = Bind(new ConstantInstr(type));
+    arguments->Add(PushArgument(type_arg));
+    const intptr_t kNumArgsChecked = 1;
+    InstanceCallInstr* call = new InstanceCallInstr(
+        node->token_pos(),
+        PrivateCoreLibName(Symbols::_as()),
+        node->kind(),
+        arguments,
+        Array::ZoneHandle(),  // No argument names.
+        kNumArgsChecked);
+    ReturnDefinition(call);
+  }
 }
 
 
 // <Expression> :: Comparison { kind:  Token::Kind
 //                              left:  <Expression>
 //                              right: <Expression> }
 // TODO(srdjan): Implement new equality.
 void EffectGraphVisitor::VisitComparisonNode(ComparisonNode* node) {
   if (Token::IsTypeTestOperator(node->kind())) {
     BuildTypeTest(node);
@@ skipping 2167 matching lines @@
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart