Fix type test elimination using static type propagation in new compiler.

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 321 matching lines @@
   if (dst_type.IsVoidType()) {
     return true;
   }
 
   // If nothing is known about the value, as is the case for passed-in
   // parameters, the test cannot be eliminated.
   if (value == NULL) {
     return false;
   }
 
-  // If nothing is known about the static type of the value, the test cannot be
-  // eliminated.
+  // Consider the static type of the value.
   const AbstractType& static_type = AbstractType::Handle(value->StaticType());
   ASSERT(!static_type.IsMalformed());
-  if (static_type.IsDynamicType()) {
-    return false;
-  }
 
   // If the static type of the value is void, the only allowed value is null,
   // which must be verified by the type test.
   if (static_type.IsVoidType()) {
     // TODO(regis): Eliminate the test if the value is constant null.
     return false;
   }
 
-  // Eliminate the test if it can be performed successfully at compile time.
+  // If the static type of the value is NullType, the type test is eliminated.
   if (static_type.IsNullType()) {
     // There are only three instances that can be of Class Null:
     // Object::null(), Object::sentinel(), and Object::transition_sentinel().
     // The inline code and run time code performing the type check will never
     // encounter the 2 sentinel values. The type check of a sentinel value
     // will always be eliminated here, because these sentinel values can only
     // be encountered as constants, never as actual value of a heap object
     // being type checked.
     return true;
   }
-  if (static_type.IsType() &&
-      Class::Handle(static_type.type_class()).HasTypeArguments()) {
-    // TODO(regis): Special tests need to be added.
-    return false;
-  }
+
+  // The run time type of the value is guaranteed to be a subtype of the 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();
-  if (!dst_type.IsMalformed() &&
-      static_type.IsSubtypeOf(dst_type, &malformed_error)) {
+  if (static_type.IsMoreSpecificThan(dst_type, &malformed_error)) {
     return true;
   }
 
   return false;
 }
 
 
 // <Expression> :: Assignable { expr:     <Expression>
 //                              type:     AbstractType
 //                              dst_name: String }
@@ skipping 2342 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