Version 0.8.10.6

dart/runtime/vm/flow_graph_type_propagator.cc

 // Copyright (c) 2013, 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_type_propagator.h"
 
 #include "vm/cha.h"
 #include "vm/bit_vector.h"
 #include "vm/il_printer.h"
 
@@ skipping 397 matching lines @@
 
   if (other->ToNullableCid() == kNullCid) {
     return;
   }
 
   if (ToNullableCid() != other->ToNullableCid()) {
     ASSERT(cid_ != kNullCid);
     cid_ = kDynamicCid;
   }
 
-  Error& malformed_error = Error::Handle();
-  if (ToAbstractType()->IsMoreSpecificThan(*other->ToAbstractType(),
-                                           &malformed_error)) {
-    type_ = other->ToAbstractType();
-  } else if (other->ToAbstractType()->IsMoreSpecificThan(*ToAbstractType(),
-                                                         &malformed_error)) {
-    // Nothing to do.
+  const AbstractType* compile_type = ToAbstractType();
+  const AbstractType* other_compile_type = other->ToAbstractType();
+  if (compile_type->IsMoreSpecificThan(*other_compile_type, NULL)) {
+    type_ = other_compile_type;
+  } else if (other_compile_type->IsMoreSpecificThan(*compile_type, NULL)) {
+  // Nothing to do.
   } else {
-    // Can't unify.
-    type_ = &Type::ZoneHandle(Type::DynamicType());
+  // Can't unify.
+  type_ = &Type::ZoneHandle(Type::DynamicType());
   }
-  ASSERT(malformed_error.IsNull());
 }
 
 
 static bool IsNullableCid(intptr_t cid) {
   ASSERT(cid != kIllegalCid);
   return cid == kNullCid || cid == kDynamicCid;
 }
 
 
 CompileType CompileType::Create(intptr_t cid, const AbstractType& type) {
@@ skipping 168 matching lines @@
     *is_instance = IsNull();
     return HasDecidableNullability();
   }
 
   // If the value can be null then we can't eliminate the
   // check unless null is allowed.
   if (is_nullable_ && !is_nullable) {
     return false;
   }
 
-  Error& malformed_error = Error::Handle();
-  *is_instance = compile_type.IsMoreSpecificThan(type, &malformed_error);
-  return malformed_error.IsNull() && *is_instance;
+  *is_instance = compile_type.IsMoreSpecificThan(type, NULL);
+  return *is_instance;
 }
 
 
 bool CompileType::IsMoreSpecificThan(const AbstractType& other) {
-  if (IsNone() || other.IsMalformed()) {
+  if (IsNone()) {
     return false;
   }
 
   if (other.IsVoidType()) {
     // The only value assignable to void is null.
     return IsNull();
   }
 
-  Error& malformed_error = Error::Handle();
-  const bool is_more_specific =
-      ToAbstractType()->IsMoreSpecificThan(other, &malformed_error);
-  return malformed_error.IsNull() && is_more_specific;
+  return ToAbstractType()->IsMoreSpecificThan(other, NULL);
 }
 
 
 CompileType* Value::Type() {
   if (reaching_type_ == NULL) {
     reaching_type_ = definition()->Type();
   }
   return reaching_type_;
 }
 
@@ skipping 564 matching lines @@
   return CompileType::FromCid(kDoubleCid);
 }
 
 
 CompileType InvokeMathCFunctionInstr::ComputeType() const {
   return CompileType::FromCid(kDoubleCid);
 }
 
 
 }  // namespace dart