Improve static type propagation.

runtime/vm/object.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/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 2515 matching lines @@
                             Error* malformed_error) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
   // In case the type checked in a type test is malformed, the code generator
   // may compile a throw instead of a run time call performing the type check.
   // However, in checked mode, a function type may include malformed result type
   // and/or malformed parameter types, which will then be encountered here at
   // run time.
   if (IsMalformed()) {
     ASSERT(FLAG_enable_type_checks);
-    if (malformed_error->IsNull()) {
+    if ((malformed_error != NULL) && malformed_error->IsNull()) {
       *malformed_error = this->malformed_error();
     }
     return false;
   }
   if (other.IsMalformed()) {
     ASSERT(FLAG_enable_type_checks);
-    if (malformed_error->IsNull()) {
+    if ((malformed_error != NULL) && malformed_error->IsNull()) {
       *malformed_error = other.malformed_error();
     }
     return false;
   }
   // AbstractType parameters cannot be handled by Class::TypeTest().
   // When comparing two uninstantiated function types, one returning type
   // parameter K, the other returning type parameter V, we cannot assume that K
   // is a subtype of V, or vice versa. We only return true if K == V, i.e. if
   // they have the same index (both are finalized, so their indices are
   // comparable).
@@ skipping 748 matching lines @@
       Error& malformed_bound_error = Error::Handle();
       if (bound.IsMalformed()) {
         malformed_bound_error = bound.malformed_error();
       } else if (!bound.IsInstantiated()) {
         bound = bound.InstantiateFrom(bounds_instantiator);
       }
       if (!malformed_bound_error.IsNull() ||
           !this_type_arg.IsSubtypeOf(bound, malformed_error)) {
         // Ignore this bound error if another malformed error was already
         // reported for this type test.
-        if (malformed_error->IsNull()) {
+        if ((malformed_error != NULL) && malformed_error->IsNull()) {
           const String& type_arg_name =
               String::Handle(this_type_arg.UserVisibleName());
           const String& class_name = String::Handle(cls.Name());
           const String& bound_name = String::Handle(bound.UserVisibleName());
           const Script& script = Script::Handle(cls.script());
           // Since the bound was canonicalized, its token index was lost,
           // therefore, use the token index of the corresponding type parameter.
           *malformed_error ^= FormatError(malformed_bound_error,
                                           script, cls_type_param.token_pos(),
                                           "type argument '%s' does not "
@@ skipping 7447 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart