Simplify code in code code generator, move checks to flow graph builder. We can assume that any typ…

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 "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 411 matching lines @@
                          owner()->try_index(),
                          interpol_func,
                          interpol_arg->names(),
                          values);
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::BuildInstanceOf(ComparisonNode* node) {
   ASSERT(Token::IsInstanceofOperator(node->kind()));
+  EffectGraphVisitor for_left_value(owner(), temp_index());
+  node->left()->Visit(&for_left_value);
+  Append(for_left_value);
+}
+
+
+void ValueGraphVisitor::BuildInstanceOf(ComparisonNode* node) {
+  ASSERT(Token::IsInstanceofOperator(node->kind()));
+  const Bool& bool_true = Bool::ZoneHandle(Bool::True());
+  const Bool& bool_false = Bool::ZoneHandle(Bool::False());
+  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(Isolate::Current()->object_store()->object_type());
+  Error& malformed_error = Error::Handle();
+  if (type.IsInstantiated() &&
+      object_type.IsSubtypeOf(type, &malformed_error)) {
+    // Must evaluate left side.
+    EffectGraphVisitor for_left_value(owner(), temp_index());
+    node->left()->Visit(&for_left_value);
+    Append(for_left_value);
+    ReturnValue(new ConstantVal(negate_result ? bool_false : bool_true));
+    return;
+  }
+
+  // Eliminate the test if it can be performed successfully at compile time.
+  if ((node->left() != NULL) &&
+      node->left()->IsLiteralNode() &&
+      type.IsInstantiated()) {
+    const Instance& literal_value = node->left()->AsLiteralNode()->literal();
+    const Class& cls = Class::Handle(literal_value.clazz());
+    ConstantVal* result = NULL;
+    if (cls.IsNullClass()) {
+      // A null object is only an instance of Object and Dynamic, which has
+      // already been checked above (if the type is instantiated). So we can
+      // return false here if the instance is null (and if the type is
+      // instantiated).
+      result = new ConstantVal(negate_result ? bool_true : bool_false);
+    } else {
+      Error& malformed_error = Error::Handle();
+      if (literal_value.IsInstanceOf(type,
+                                     TypeArguments::Handle(),
+                                     &malformed_error)) {
+        result = new ConstantVal(negate_result ? bool_false : bool_true);
+      } else {
+        ASSERT(malformed_error.IsNull());
+        result = new ConstantVal(negate_result ? bool_true : bool_false);
+      }
+    }
+    ReturnValue(result);
+    return;
+  }
+
   ArgumentGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
-  const AbstractType& type = node->right()->AsTypeNode()->type();
-  ASSERT(type.IsFinalized() && !type.IsMalformed());
   Value* type_arguments = NULL;
   if (!type.IsInstantiated()) {
     type_arguments = BuildInstantiatorTypeArguments(
         node->token_index(), for_left_value.temp_index());
   }
   InstanceOfComp* instance_of = new InstanceOfComp(
       node->id(),
       node->token_index(),
       owner()->try_index(),
       for_left_value.value(),
@@ skipping 2102 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(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