Improve static type propagation.

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/bit_vector.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 447 matching lines @@
   // compile time static type of the value. However, establishing here that
   // the static type is a subtype of the destination type does not guarantee
   // that the run time type will also be a subtype of the destination type,
   // because the subtype relation is not transitive.
   // However, the 'more specific than' relation is transitive and is used
   // here. In other words, if the static type of the value is more specific
   // than the destination type, the run time type of the value, which is
   // guaranteed to be a subtype of the static type, is also guaranteed to be
   // a subtype of the destination type and the type check can therefore be
   // eliminated.
-  Error& malformed_error = Error::Handle();
-  return static_type.IsMoreSpecificThan(dst_type, &malformed_error);
+  return static_type.IsMoreSpecificThan(dst_type, NULL);
 }
 
 
 // Returns true if the type check can be skipped, for example, if the
 // destination type is Dynamic or if the static type of the value is a subtype
 // of the destination type.
 bool EffectGraphVisitor::CanSkipTypeCheck(intptr_t token_pos,
                                           Value* value,
                                           const AbstractType& dst_type,
                                           const String& dst_name) {
@@ skipping 250 matching lines @@
 
 void ValueGraphVisitor::BuildTypeTest(ComparisonNode* node) {
   ASSERT(Token::IsTypeTestOperator(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(Type::ObjectType());
-  Error& malformed_error = Error::Handle();
-  if (type.IsInstantiated() &&
-      object_type.IsSubtypeOf(type, &malformed_error)) {
+  if (type.IsInstantiated() && object_type.IsSubtypeOf(type, NULL)) {
     // Must evaluate left side.
     EffectGraphVisitor for_left_value(owner(), temp_index());
     node->left()->Visit(&for_left_value);
     Append(for_left_value);
     ReturnComputation(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)) {
+      if (literal_value.IsInstanceOf(type, TypeArguments::Handle(), NULL)) {
         result = new ConstantVal(negate_result ? bool_false : bool_true);
       } else {
-        ASSERT(malformed_error.IsNull());
         result = new ConstantVal(negate_result ? bool_true : bool_false);
       }
     }
     ReturnComputation(result);
     return;
   }
 
   ValueGraphVisitor for_left_value(owner(), temp_index());
   node->left()->Visit(&for_left_value);
   Append(for_left_value);
@@ skipping 731 matching lines @@
   const bool requires_type_arguments = cls.HasTypeArguments();
 
   ZoneGrowableArray<Value*>* allocate_arguments =
       new ZoneGrowableArray<Value*>();
   if (requires_type_arguments) {
     BuildConstructorTypeArguments(node, allocate_arguments);
   }
   // In checked mode, if the type arguments are uninstantiated, they may need to
   // be checked against declared bounds at run time.
   Computation* allocate_comp = NULL;
-  Error& malformed_error = Error::Handle();
   if (FLAG_enable_type_checks &&
       requires_type_arguments &&
       !node->type_arguments().IsNull() &&
       !node->type_arguments().IsInstantiated() &&
       !node->type_arguments().IsWithinBoundsOf(cls,
                                                node->type_arguments(),
-                                               &malformed_error)) {
+                                               NULL)) {
     // The uninstantiated type arguments cannot be verified to be within their
     // bounds at compile time, so verify them at runtime.
     // Although the type arguments may be uninstantiated at compile time, they
     // may represent the identity vector and may be replaced by the instantiated
     // type arguments of the instantiator at run time.
     allocate_comp = new AllocateObjectWithBoundsCheckComp(node,
                                                           owner()->try_index(),
                                                           allocate_arguments);
   } else {
     allocate_comp = new AllocateObjectComp(node,
@@ skipping 1189 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