More cleanup related to malformed and malbounded types.

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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 43 matching lines @@
 DEFINE_FLAG(int, huge_method_cutoff_in_code_size, 200000,
     "Huge method cutoff in unoptimized code size (in bytes).");
 DEFINE_FLAG(bool, throw_on_javascript_int_overflow, false,
     "Throw an exception when the result of an integer calculation will not "
     "fit into a javascript integer.");
 DECLARE_FLAG(bool, trace_compiler);
 DECLARE_FLAG(bool, eliminate_type_checks);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, trace_deoptimization);
 DECLARE_FLAG(bool, trace_deoptimization_verbose);
-DECLARE_FLAG(bool, error_on_malformed_type);
+DECLARE_FLAG(bool, error_on_bad_type);
 DECLARE_FLAG(bool, error_on_bad_override);
 
 static const char* kGetterPrefix = "get:";
 static const intptr_t kGetterPrefixLength = strlen(kGetterPrefix);
 static const char* kSetterPrefix = "set:";
 static const intptr_t kSetterPrefixLength = strlen(kSetterPrefix);
 
 cpp_vtable Object::handle_vtable_ = 0;
 cpp_vtable Object::builtin_vtables_[kNumPredefinedCids] = { 0 };
 cpp_vtable Smi::handle_vtable_ = 0;
@@ skipping 2386 matching lines @@
 // If test_kind == kIsMoreSpecificThan, checks if S is more specific than T.
 // Type S is specified by this class parameterized with 'type_arguments', and
 // type T by class 'other' parameterized with 'other_type_arguments'.
 // This class and class 'other' do not need to be finalized, however, they must
 // be resolved as well as their interfaces.
 bool Class::TypeTest(
     TypeTestKind test_kind,
     const AbstractTypeArguments& type_arguments,
     const Class& other,
     const AbstractTypeArguments& other_type_arguments,
-    Error* malformed_error) const {
+    Error* bound_error) const {
   ASSERT(!IsVoidClass());
   // Check for DynamicType.
   // Each occurrence of DynamicType in type T is interpreted as the dynamic
   // type, a supertype of all types.
   if (other.IsDynamicClass()) {
     return true;
   }
   // In the case of a subtype test, each occurrence of DynamicType in type S is
   // interpreted as the bottom type, a subtype of all types.
   // However, DynamicType is not more specific than any type.
@@ skipping 26 matching lines @@
     }
     if (type_arguments.IsNull() || type_arguments.IsRaw(len)) {
       // Other type can't be more specific than this one because for that
       // it would have to have all dynamic type arguments which is checked
       // above.
       return test_kind == kIsSubtypeOf;
     }
     return type_arguments.TypeTest(test_kind,
                                    other_type_arguments,
                                    len,
-                                   malformed_error);
+                                   bound_error);
   }
   const bool other_is_function_class = other.IsFunctionClass();
   if (other.IsSignatureClass() || other_is_function_class) {
     const Function& other_fun = Function::Handle(other.signature_function());
     if (IsSignatureClass()) {
       if (other_is_function_class) {
         return true;
       }
       // Check for two function types.
       const Function& fun = Function::Handle(signature_function());
       return fun.TypeTest(test_kind,
                           type_arguments,
                           other_fun,
                           other_type_arguments,
-                          malformed_error);
+                          bound_error);
     }
     // Check if type S has a call() method of function type T.
     Function& function =
         Function::Handle(LookupDynamicFunction(Symbols::Call()));
     if (function.IsNull()) {
       // Walk up the super_class chain.
       Class& cls = Class::Handle(SuperClass());
       while (!cls.IsNull() && function.IsNull()) {
         function = cls.LookupDynamicFunction(Symbols::Call());
         cls = cls.SuperClass();
       }
     }
     if (!function.IsNull()) {
       if (other_is_function_class ||
           function.TypeTest(test_kind,
                             type_arguments,
                             other_fun,
                             other_type_arguments,
-                            malformed_error)) {
+                            bound_error)) {
         return true;
       }
     }
   }
   // Check for 'direct super type' specified in the implements clause
   // and check for transitivity at the same time.
   Array& interfaces = Array::Handle(this->interfaces());
   AbstractType& interface = AbstractType::Handle();
   Class& interface_class = Class::Handle();
   AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
-  Error& args_malformed_error = Error::Handle();
+  Error& args_bound_error = Error::Handle();
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
     interface ^= interfaces.At(i);
     if (!interface.IsFinalized()) {
       // We may be checking bounds at finalization time. Skipping this
       // unfinalized interface will postpone bound checking to run time.
       continue;
     }
     interface_class = interface.type_class();
     interface_args = interface.arguments();
     if (!interface_args.IsNull() && !interface_args.IsInstantiated()) {
       // This type class implements an interface that is parameterized with
       // generic type(s), e.g. it implements List<T>.
       // The uninstantiated type T must be instantiated using the type
       // parameters of this type before performing the type test.
       // The type arguments of this type that are referred to by the type
       // parameters of the interface are at the end of the type vector,
       // after the type arguments of the super type of this type.
       // The index of the type parameters is adjusted upon finalization.
-      args_malformed_error = Error::null();
+      args_bound_error = Error::null();
       interface_args = interface_args.InstantiateFrom(type_arguments,
-                                                      &args_malformed_error);
-      if (!args_malformed_error.IsNull()) {
-        // Return the first malformed error to the caller if it requests it.
-        if ((malformed_error != NULL) && malformed_error->IsNull()) {
-          *malformed_error = args_malformed_error.raw();
+                                                      &args_bound_error);
+      if (!args_bound_error.IsNull()) {
+        // Return the first bound error to the caller if it requests it.
+        if ((bound_error != NULL) && bound_error->IsNull()) {
+          *bound_error = args_bound_error.raw();
         }
         continue;  // Another interface may work better.
       }
     }
     if (interface_class.TypeTest(test_kind,
                                  interface_args,
                                  other,
                                  other_type_arguments,
-                                 malformed_error)) {
+                                 bound_error)) {
       return true;
     }
   }
   const Class& super_class = Class::Handle(SuperClass());
   if (super_class.IsNull()) {
     return false;
   }
   // Instead of truncating the type argument vector to the length of the super
   // type argument vector, we make sure that the code works with a vector that
   // is longer than necessary.
   return super_class.TypeTest(test_kind,
                               type_arguments,
                               other,
                               other_type_arguments,
-                              malformed_error);
+                              bound_error);
 }
 
 
 bool Class::IsTopLevel() const {
   return Name() == Symbols::TopLevel().raw();
 }
 
 
 RawFunction* Class::LookupDynamicFunction(const String& name) const {
   return LookupFunction(name, kInstance);
@@ skipping 535 matching lines @@
   }
   if (other_arguments.IsNull()) {
     return arguments.IsDynamicTypes(false, arguments.Length());
   }
   return arguments.Equals(other_arguments);
 }
 
 
 RawAbstractTypeArguments* AbstractTypeArguments::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments,
-    Error* malformed_error) const {
+    Error* bound_error) const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 bool AbstractTypeArguments::IsDynamicTypes(bool raw_instantiated,
                                            intptr_t len) const {
   ASSERT(Length() >= len);
   AbstractType& type = AbstractType::Handle();
@@ skipping 17 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 
 bool AbstractTypeArguments::TypeTest(TypeTestKind test_kind,
                                      const AbstractTypeArguments& other,
                                      intptr_t len,
-                                     Error* malformed_error) const {
+                                     Error* bound_error) const {
   ASSERT(Length() >= len);
   ASSERT(!other.IsNull());
   ASSERT(other.Length() >= len);
   AbstractType& type = AbstractType::Handle();
   AbstractType& other_type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(i);
     ASSERT(!type.IsNull());
     other_type = other.TypeAt(i);
     ASSERT(!other_type.IsNull());
-    if (!type.TypeTest(test_kind, other_type, malformed_error)) {
+    if (!type.TypeTest(test_kind, other_type, bound_error)) {
       return false;
     }
   }
   return true;
 }
 
 
 const char* AbstractTypeArguments::ToCString() const {
   // AbstractTypeArguments is an abstract class, valid only for representing
   // null.
@@ skipping 161 matching lines @@
     if (!type_args.IsNull() && type_args.IsBounded()) {
       return true;
     }
   }
   return false;
 }
 
 
 RawAbstractTypeArguments* TypeArguments::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments,
-    Error* malformed_error) const {
+    Error* bound_error) const {
   ASSERT(!IsInstantiated());
   if (!instantiator_type_arguments.IsNull() &&
       IsUninstantiatedIdentity() &&
       (instantiator_type_arguments.Length() == Length())) {
     return instantiator_type_arguments.raw();
   }
   const intptr_t num_types = Length();
   TypeArguments& instantiated_array =
       TypeArguments::Handle(TypeArguments::New(num_types, Heap::kNew));
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsInstantiated()) {
-      type = type.InstantiateFrom(instantiator_type_arguments, malformed_error);
+      type = type.InstantiateFrom(instantiator_type_arguments, bound_error);
     }
     instantiated_array.SetTypeAt(i, type);
   }
   return instantiated_array.raw();
 }
 
 
 RawTypeArguments* TypeArguments::New(intptr_t len, Heap::Space space) {
   if (len < 0 || len > kMaxElements) {
     // This should be caught before we reach here.
@@ skipping 162 matching lines @@
       uninstantiated_type_arguments()).Length();
 }
 
 
 RawAbstractType* InstantiatedTypeArguments::TypeAt(intptr_t index) const {
   AbstractType& type = AbstractType::Handle(AbstractTypeArguments::Handle(
       uninstantiated_type_arguments()).TypeAt(index));
   if (!type.IsInstantiated()) {
     const AbstractTypeArguments& instantiator_type_args =
         AbstractTypeArguments::Handle(instantiator_type_arguments());
-    Error& malformed_error = Error::Handle();
-    type = type.InstantiateFrom(instantiator_type_args, &malformed_error);
+    Error& bound_error = Error::Handle();
+    type = type.InstantiateFrom(instantiator_type_args, &bound_error);
     // InstantiatedTypeArguments cannot include unchecked bounds.
     // In the presence of unchecked bounds, no InstantiatedTypeArguments are
     // allocated, but the type arguments are instantiated individually and their
     // bounds are checked.
-    ASSERT(malformed_error.IsNull());
+    ASSERT(bound_error.IsNull());
   }
   return type.raw();
 }
 
 
 void InstantiatedTypeArguments::SetTypeAt(intptr_t index,
                                           const AbstractType& value) const {
   // We only replace individual argument types during resolution at compile
   // time, when no type parameters are instantiated yet.
   UNREACHABLE();
@@ skipping 799 matching lines @@
 
 
 const char* Function::ToFullyQualifiedCString() const {
   char* chars = NULL;
   ConstructFunctionFullyQualifiedCString(*this, &chars, 0);
   return chars;
 }
 
 
 bool Function::HasCompatibleParametersWith(const Function& other,
-                                           Error* error) const {
+                                           Error* bound_error) const {
   ASSERT(FLAG_error_on_bad_override);
   // Check that this function's signature type is a subtype of the other
   // function's signature type.
   if (!TypeTest(kIsSubtypeOf, Object::null_abstract_type_arguments(),
-                other, Object::null_abstract_type_arguments(), error)) {
+                other, Object::null_abstract_type_arguments(), bound_error)) {
     // For more informative error reporting, use the location of the other
     // function here, since the caller will use the location of this function.
-    *error = FormatError(
-        *error,  // A malformed error if non null.
+    *bound_error = FormatError(
+        *bound_error,  // A bound error if non null.
         Script::Handle(other.script()),
         other.token_pos(),
         "signature type '%s' of function '%s' is not a subtype of signature "
         "type '%s' of function '%s'",
         String::Handle(UserVisibleSignature()).ToCString(),
         String::Handle(UserVisibleName()).ToCString(),
         String::Handle(other.UserVisibleSignature()).ToCString(),
         String::Handle(other.UserVisibleName()).ToCString());
     return false;
   }
@@ skipping 15 matching lines @@
 // parameter of the other function.
 // Note that we do not apply contravariance of parameter types, but covariance
 // of both parameter types and result type.
 bool Function::TestParameterType(
     TypeTestKind test_kind,
     intptr_t parameter_position,
     intptr_t other_parameter_position,
     const AbstractTypeArguments& type_arguments,
     const Function& other,
     const AbstractTypeArguments& other_type_arguments,
-    Error* malformed_error) const {
+    Error* bound_error) const {
   AbstractType& other_param_type =
       AbstractType::Handle(other.ParameterTypeAt(other_parameter_position));
   if (!other_param_type.IsInstantiated()) {
     other_param_type = other_param_type.InstantiateFrom(other_type_arguments,
-                                                        malformed_error);
-    ASSERT((malformed_error == NULL) || malformed_error->IsNull());
+                                                        bound_error);
+    ASSERT((bound_error == NULL) || bound_error->IsNull());
   }
   if (other_param_type.IsDynamicType()) {
     return true;
   }
   AbstractType& param_type =
       AbstractType::Handle(ParameterTypeAt(parameter_position));
   if (!param_type.IsInstantiated()) {
-    param_type = param_type.InstantiateFrom(type_arguments, malformed_error);
-    ASSERT((malformed_error == NULL) || malformed_error->IsNull());
+    param_type = param_type.InstantiateFrom(type_arguments, bound_error);
+    ASSERT((bound_error == NULL) || bound_error->IsNull());
   }
   if (param_type.IsDynamicType()) {
     return test_kind == kIsSubtypeOf;
   }
   if (test_kind == kIsSubtypeOf) {
-    if (!param_type.IsSubtypeOf(other_param_type, malformed_error) &&
-        !other_param_type.IsSubtypeOf(param_type, malformed_error)) {
+    if (!param_type.IsSubtypeOf(other_param_type, bound_error) &&
+        !other_param_type.IsSubtypeOf(param_type, bound_error)) {
       return false;
     }
   } else {
     ASSERT(test_kind == kIsMoreSpecificThan);
-    if (!param_type.IsMoreSpecificThan(other_param_type, malformed_error)) {
+    if (!param_type.IsMoreSpecificThan(other_param_type, bound_error)) {
       return false;
     }
   }
   return true;
 }
 
 
 bool Function::TypeTest(TypeTestKind test_kind,
                         const AbstractTypeArguments& type_arguments,
                         const Function& other,
                         const AbstractTypeArguments& other_type_arguments,
-                        Error* malformed_error) const {
+                        Error* bound_error) const {
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_pos_params = NumOptionalPositionalParameters();
   const intptr_t num_opt_named_params = NumOptionalNamedParameters();
   const intptr_t other_num_fixed_params = other.num_fixed_parameters();
   const intptr_t other_num_opt_pos_params =
       other.NumOptionalPositionalParameters();
   const intptr_t other_num_opt_named_params =
       other.NumOptionalNamedParameters();
   // This function requires the same arguments or less and accepts the same
   // arguments or more.
   // A generative constructor may be compared to a redirecting factory and be
   // compatible although it has an additional phase parameter.
   // More generally, we can ignore implicit parameters.
   const intptr_t num_ignored_params = NumImplicitParameters();
   const intptr_t other_num_ignored_params = other.NumImplicitParameters();
   if (((num_fixed_params - num_ignored_params) >
        (other_num_fixed_params - other_num_ignored_params)) ||
       ((num_fixed_params - num_ignored_params + num_opt_pos_params) <
        (other_num_fixed_params - other_num_ignored_params +
         other_num_opt_pos_params)) ||
       (num_opt_named_params < other_num_opt_named_params)) {
     return false;
   }
   // Check the result type.
   AbstractType& other_res_type = AbstractType::Handle(other.result_type());
   if (!other_res_type.IsInstantiated()) {
     other_res_type = other_res_type.InstantiateFrom(other_type_arguments,
-                                                    malformed_error);
-    ASSERT((malformed_error == NULL) || malformed_error->IsNull());
+                                                    bound_error);
+    ASSERT((bound_error == NULL) || bound_error->IsNull());
   }
   if (!other_res_type.IsDynamicType() && !other_res_type.IsVoidType()) {
     AbstractType& res_type = AbstractType::Handle(result_type());
     if (!res_type.IsInstantiated()) {
-      res_type = res_type.InstantiateFrom(type_arguments, malformed_error);
-      ASSERT((malformed_error == NULL) || malformed_error->IsNull());
+      res_type = res_type.InstantiateFrom(type_arguments, bound_error);
+      ASSERT((bound_error == NULL) || bound_error->IsNull());
     }
     if (res_type.IsVoidType()) {
       return false;
     }
     if (test_kind == kIsSubtypeOf) {
-      if (!res_type.IsSubtypeOf(other_res_type, malformed_error) &&
-          !other_res_type.IsSubtypeOf(res_type, malformed_error)) {
+      if (!res_type.IsSubtypeOf(other_res_type, bound_error) &&
+          !other_res_type.IsSubtypeOf(res_type, bound_error)) {
         return false;
       }
     } else {
       ASSERT(test_kind == kIsMoreSpecificThan);
-      if (!res_type.IsMoreSpecificThan(other_res_type, malformed_error)) {
+      if (!res_type.IsMoreSpecificThan(other_res_type, bound_error)) {
         return false;
       }
     }
   }
   // Check the types of fixed and optional positional parameters.
   for (intptr_t i = 0; i < (other_num_fixed_params - other_num_ignored_params +
                             other_num_opt_pos_params); i++) {
     if (!TestParameterType(test_kind,
                            i + num_ignored_params, i + other_num_ignored_params,
                            type_arguments, other, other_type_arguments,
-                           malformed_error)) {
+                           bound_error)) {
       return false;
     }
   }
   // Check the names and types of optional named parameters.
   if (other_num_opt_named_params == 0) {
     return true;
   }
   // Check that for each optional named parameter of type T of the other
   // function type, there exists an optional named parameter of this function
   // type with an identical name and with a type S that is a either a subtype
@@ skipping 10 matching lines @@
     other_param_name = other.ParameterNameAt(i);
     ASSERT(other_param_name.IsSymbol());
     found_param_name = false;
     for (intptr_t j = num_fixed_params; j < num_params; j++) {
       ASSERT(String::Handle(ParameterNameAt(j)).IsSymbol());
       if (ParameterNameAt(j) == other_param_name.raw()) {
         found_param_name = true;
         if (!TestParameterType(test_kind,
                                j, i,
                                type_arguments, other, other_type_arguments,
-                               malformed_error)) {
+                               bound_error)) {
           return false;
         }
         break;
       }
     }
     if (!found_param_name) {
       return false;
     }
   }
   return true;
@@ skipping 5641 matching lines @@
 
 
 void Instance::SetTypeArguments(const AbstractTypeArguments& value) const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   SetFieldAtOffset(field_offset, value);
 }
 
 
-// TODO(regis): Rename malformed_error to bound_error.
 bool Instance::IsInstanceOf(const AbstractType& other,
                             const AbstractTypeArguments& other_instantiator,
-                            Error* malformed_error) const {
+                            Error* bound_error) const {
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsMalformed());
   ASSERT(!other.IsMalbounded());
   if (other.IsVoidType()) {
     return false;
   }
   const Class& cls = Class::Handle(clazz());
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   const intptr_t num_type_arguments = cls.NumTypeArguments();
@@ skipping 12 matching lines @@
     // Also, an optimization reuses the type argument vector of the instantiator
     // of generic instances when its layout is compatible.
     ASSERT(type_arguments.IsNull() ||
            (type_arguments.Length() >= num_type_arguments));
   }
   Class& other_class = Class::Handle();
   AbstractTypeArguments& other_type_arguments = AbstractTypeArguments::Handle();
   // Note that we may encounter a bound error in checked mode.
   if (!other.IsInstantiated()) {
     const AbstractType& instantiated_other = AbstractType::Handle(
-        other.InstantiateFrom(other_instantiator, malformed_error));
-    if ((malformed_error != NULL) && !malformed_error->IsNull()) {
+        other.InstantiateFrom(other_instantiator, bound_error));
+    if ((bound_error != NULL) && !bound_error->IsNull()) {
       ASSERT(FLAG_enable_type_checks);
       return false;
     }
     other_class = instantiated_other.type_class();
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
     other_type_arguments = other.arguments();
   }
   return cls.IsSubtypeOf(type_arguments, other_class, other_type_arguments,
-                         malformed_error);
+                         bound_error);
 }
 
 
 void Instance::SetNativeField(int index, intptr_t value) const {
   ASSERT(IsValidNativeIndex(index));
   Object& native_fields = Object::Handle(*NativeFieldsAddr());
   if (native_fields.IsNull()) {
     // Allocate backing storage for the native fields.
     const Class& cls = Class::Handle(clazz());
     int num_native_fields = cls.num_native_fields();
@@ skipping 194 matching lines @@
 
 bool AbstractType::Equals(const Instance& other) const {
   // AbstractType is an abstract class.
   ASSERT(raw() == AbstractType::null());
   return other.IsNull();
 }
 
 
 RawAbstractType* AbstractType::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments,
-    Error* malformed_error) const {
+    Error* bound_error) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 RawAbstractType* AbstractType::Canonicalize() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
@@ skipping 149 matching lines @@
 
 
 bool AbstractType::IsFunctionType() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::Function()).type_class());
 }
 
 
 bool AbstractType::TypeTest(TypeTestKind test_kind,
                             const AbstractType& other,
-                            Error* malformed_error) const {
+                            Error* bound_error) const {
   ASSERT(IsResolved());
   ASSERT(other.IsResolved());
-  // In case the type checked in a type test is malformed, the code generator
+  ASSERT(!IsMalformed());
+  ASSERT(!other.IsMalformed());
+  // In case the type checked in a type test is malbounded, 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()) {
+  // However, in checked mode, a function type may include malbounded result
+  // type and/or malbounded parameter types, which will then be encountered here
+  // at run time.
+  if (IsMalbounded()) {
     ASSERT(FLAG_enable_type_checks);
-    if ((malformed_error != NULL) && malformed_error->IsNull()) {
-      *malformed_error = this->malformed_error();
+    if ((bound_error != NULL) && bound_error->IsNull()) {
+      const bool is_malbounded = IsMalboundedWithError(bound_error);
+      ASSERT(is_malbounded);
     }
     return false;
   }
-  if (other.IsMalformed()) {
-    // Note that 'other' may represent an unresolved bound that is checked at
-    // compile time, even in production mode, in which case the resulting
-    // BoundedType is ignored at run time if in production mode.
-    // Therefore, we cannot assert that we are in checked mode here.
-    if ((malformed_error != NULL) && malformed_error->IsNull()) {
-      *malformed_error = other.malformed_error();
+  if (other.IsMalbounded()) {
+    ASSERT(FLAG_enable_type_checks);
+    if ((bound_error != NULL) && bound_error->IsNull()) {
+      const bool other_is_malbounded = other.IsMalboundedWithError(bound_error);
+      ASSERT(other_is_malbounded);
     }
     return false;
   }
   if (IsBoundedType() || other.IsBoundedType()) {
     if (Equals(other)) {
       return true;
     }
     return false;  // TODO(regis): We should return "maybe after instantiation".
   }
   // Type parameters cannot be handled by Class::TypeTest().
@@ skipping 10 matching lines @@
   // uninstantiated at compile time.
   if (IsTypeParameter()) {
     const TypeParameter& type_param = TypeParameter::Cast(*this);
     if (other.IsTypeParameter()) {
       const TypeParameter& other_type_param = TypeParameter::Cast(other);
       if (type_param.Equals(other_type_param)) {
         return true;
       }
     }
     const AbstractType& bound = AbstractType::Handle(type_param.bound());
-    if (bound.IsMoreSpecificThan(other, malformed_error)) {
+    if (bound.IsMoreSpecificThan(other, bound_error)) {
       return true;
     }
     return false;  // TODO(regis): We should return "maybe after instantiation".
   }
   if (other.IsTypeParameter()) {
     return false;  // TODO(regis): We should return "maybe after instantiation".
   }
   const Class& cls = Class::Handle(type_class());
   return cls.TypeTest(test_kind,
                       AbstractTypeArguments::Handle(arguments()),
                       Class::Handle(other.type_class()),
                       AbstractTypeArguments::Handle(other.arguments()),
-                      malformed_error);
+                      bound_error);
 }
 
 
 intptr_t AbstractType::Hash() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return 0;
 }
 
 
@@ skipping 120 matching lines @@
   set_type_state(RawType::kBeingFinalized);
 }
 
 
 bool Type::IsMalformed() const {
   return raw_ptr()->malformed_error_ != Error::null();
 }
 
 
 bool Type::IsMalboundedWithError(Error* bound_error) const {
-  if (!FLAG_enable_type_checks && !FLAG_error_on_malformed_type) {
+  if (!FLAG_enable_type_checks && !FLAG_error_on_bad_type) {
     return false;
   }
-  ASSERT(IsFinalized());
+  ASSERT(IsResolved());
   ASSERT(!IsMalformed());  // Must be checked first.
   if (arguments() == AbstractTypeArguments::null()) {
     return false;
   }
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(arguments());
   const intptr_t num_type_args = type_arguments.Length();
   AbstractType& type_arg = AbstractType::Handle();
   for (intptr_t i = 0; i < num_type_args; i++) {
     type_arg = type_arguments.TypeAt(i);
@@ skipping 87 matching lines @@
     return false;
   }
   const AbstractTypeArguments& args =
       AbstractTypeArguments::Handle(arguments());
   return args.IsNull() || args.IsInstantiated();
 }
 
 
 RawAbstractType* Type::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments,
-    Error* malformed_error) const {
+    Error* bound_error) const {
   ASSERT(IsResolved());
   ASSERT(!IsInstantiated());
   // Return the uninstantiated type unchanged if malformed. No copy needed.
   if (IsMalformed()) {
     return raw();
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(arguments());
   type_arguments = type_arguments.InstantiateFrom(instantiator_type_arguments,
-                                                  malformed_error);
+                                                  bound_error);
   // Note that the type class has to be resolved at this time, but not
   // necessarily finalized yet. We may be checking bounds at compile time.
   const Class& cls = Class::Handle(type_class());
   // This uninstantiated type is not modified, as it can be instantiated
   // with different instantiators.
   Type& instantiated_type = Type::Handle(
       Type::New(cls, type_arguments, token_pos()));
   ASSERT(type_arguments.IsNull() ||
          (type_arguments.Length() == cls.NumTypeArguments()));
   instantiated_type.SetIsFinalized();
@@ skipping 242 matching lines @@
 }
 
 
 void TypeParameter::set_bound(const AbstractType& value) const {
   StorePointer(&raw_ptr()->bound_, value.raw());
 }
 
 
 RawAbstractType* TypeParameter::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments,
-    Error* malformed_error) const {
+    Error* bound_error) const {
   ASSERT(IsFinalized());
   if (instantiator_type_arguments.IsNull()) {
     return Type::DynamicType();
   }
   // Bound checks may appear in the instantiator type arguments, as is the case
   // with a pair of type parameters of the same class referring to each other
   // via their bounds.
   AbstractType& type_arg = AbstractType::Handle(
       instantiator_type_arguments.TypeAt(index()));
   if (type_arg.IsBoundedType()) {
     const BoundedType& bounded_type = BoundedType::Cast(type_arg);
     // Bounds checking of a type is postponed to run time if the type is still
     // uninstantiated at compile time, or if the bound and the type are mutually
     // recursive. In the latter case, the type may already be instantiated.
     if (!bounded_type.IsInstantiated()) {
       ASSERT(AbstractType::Handle(bounded_type.bound()).IsInstantiated());
       type_arg = bounded_type.InstantiateFrom(AbstractTypeArguments::Handle(),
-                                              malformed_error);
+                                              bound_error);
     }
   }
   return type_arg.raw();
 }
 
 
 bool TypeParameter::CheckBound(const AbstractType& bounded_type,
                                const AbstractType& upper_bound,
-                               Error* malformed_error) const {
-  ASSERT((malformed_error == NULL) || malformed_error->IsNull());
+                               Error* bound_error) const {
+  ASSERT((bound_error == NULL) || bound_error->IsNull());
   ASSERT(bounded_type.IsFinalized());
   ASSERT(upper_bound.IsFinalized());
   ASSERT(!bounded_type.IsMalformed());
-  if (bounded_type.IsSubtypeOf(upper_bound, malformed_error)) {
+  if (bounded_type.IsSubtypeOf(upper_bound, bound_error)) {
     return true;
   }
-  if ((malformed_error != NULL) && malformed_error->IsNull()) {
+  if ((bound_error != NULL) && bound_error->IsNull()) {
     // Report the bound error.
     const String& bounded_type_name = String::Handle(
         bounded_type.UserVisibleName());
     const String& upper_bound_name = String::Handle(
         upper_bound.UserVisibleName());
     const AbstractType& declared_bound = AbstractType::Handle(bound());
     const String& declared_bound_name = String::Handle(
         declared_bound.UserVisibleName());
     const String& type_param_name = String::Handle(UserVisibleName());
     const Class& cls = Class::Handle(parameterized_class());
     const String& class_name = String::Handle(cls.Name());
     const Script& script = Script::Handle(cls.script());
     // Since the bound may have been canonicalized, its token index is
     // meaningless, therefore use the token index of this type parameter.
-    *malformed_error = FormatError(
-        *malformed_error,
+    *bound_error = FormatError(
+        *bound_error,
         script,
         token_pos(),
         "type parameter '%s' of class '%s' must extend bound '%s', "
         "but type argument '%s' is not a subtype of '%s'\n",
         type_param_name.ToCString(),
         class_name.ToCString(),
         declared_bound_name.ToCString(),
         bounded_type_name.ToCString(),
         upper_bound_name.ToCString());
   }
@@ skipping 69 matching lines @@
   stream->CloseObject();
 }
 
 
 bool BoundedType::IsMalformed() const {
   return AbstractType::Handle(type()).IsMalformed();
 }
 
 
 bool BoundedType::IsMalboundedWithError(Error* bound_error) const {
-  if (!FLAG_enable_type_checks && !FLAG_error_on_malformed_type) {
+  if (!FLAG_enable_type_checks && !FLAG_error_on_bad_type) {
     return false;
   }
   const AbstractType& upper_bound = AbstractType::Handle(bound());
   if (upper_bound.IsMalformed()) {
     if (bound_error != NULL) {
       *bound_error = upper_bound.malformed_error();
       ASSERT(!bound_error->IsNull());
     }
     return true;
   }
@@ skipping 56 matching lines @@
 }
 
 
 void BoundedType::set_is_being_checked(bool value) const {
   raw_ptr()->is_being_checked_ = value;
 }
 
 
 RawAbstractType* BoundedType::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments,
-    Error* malformed_error) const {
+    Error* bound_error) const {
   ASSERT(IsFinalized());
   AbstractType& bounded_type = AbstractType::Handle(type());
   if (!bounded_type.IsInstantiated()) {
     bounded_type = bounded_type.InstantiateFrom(instantiator_type_arguments,
-                                                malformed_error);
+                                                bound_error);
   }
   if (FLAG_enable_type_checks &&
-      malformed_error->IsNull() &&
+      bound_error->IsNull() &&
       !is_being_checked()) {
     // Avoid endless recursion while checking and instantiating bound.
     set_is_being_checked(true);
     AbstractType& upper_bound = AbstractType::Handle(bound());
     ASSERT(!upper_bound.IsObjectType() && !upper_bound.IsDynamicType());
     const TypeParameter& type_param = TypeParameter::Handle(type_parameter());
     if (!upper_bound.IsInstantiated()) {
       upper_bound = upper_bound.InstantiateFrom(instantiator_type_arguments,
-                                                malformed_error);
+                                                bound_error);
     }
-    if (malformed_error->IsNull()) {
-      type_param.CheckBound(bounded_type, upper_bound, malformed_error);
+    if (bound_error->IsNull()) {
+      type_param.CheckBound(bounded_type, upper_bound, bound_error);
     }
     set_is_being_checked(false);
   }
   return bounded_type.raw();
 }
 
 
 intptr_t BoundedType::Hash() const {
   uword result = 0;
   result += AbstractType::Handle(type()).Hash();
@@ skipping 3323 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart