Prevent expensive and unnecessary error formatting in the case a bound check is

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/bigint_operations.h"
@@ skipping 2843 matching lines @@
     const TypeParameter& type_param = TypeParameter::Cast(type);
     ASSERT(type_param.IsFinalized());
     if ((type_param.index() != i)) {
       return false;
     }
     // If this type parameter specifies an upper bound, then the type argument
     // vector does not really represent the identity vector. It cannot be
     // substituted by the instantiator's type argument vector without checking
     // the upper bound.
     const AbstractType& bound = AbstractType::Handle(type_param.bound());
-    ASSERT(bound.IsFinalized());
+    ASSERT(bound.IsResolved());
     if (!bound.IsObjectType() && !bound.IsDynamicType()) {
       return false;
     }
   }
   return true;
 }
 
 
 bool TypeArguments::IsBounded() const {
   AbstractType& type = AbstractType::Handle();
@@ skipping 6381 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 {
-  ASSERT(IsFinalized());
-  ASSERT(other.IsFinalized());
+  ASSERT(IsResolved());
+  ASSERT(other.IsResolved());
   // 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 != NULL) && malformed_error->IsNull()) {
       *malformed_error = this->malformed_error();
     }
@@ skipping 16 matching lines @@
     return false;  // TODO(regis): We should return "maybe after instantiation".
   }
   // Type 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 equals V, as
   // defined by TypeParameter::Equals.
   // The same rule applies when checking the upper bound of a still
   // uninstantiated type at compile time. Returning false will defer the test
   // to run time.
-  // We may think that some cases can be decided at compile time.
+  // There are however some cases can be decided at compile time.
   // For example, with class A<K, V extends K>, new A<T, T> called from within
   // a class B<T> will never require a run time bound check, even if T is
   // uninstantiated at compile time.
-  // However, this is not true, because bounds are ignored in production mode,
-  // and even if we are running in checked mode, we may generate a snapshot
-  // that will be executed in production mode.
   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)) {
+      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()),
@@ skipping 196 matching lines @@
   }
   const AbstractTypeArguments& args =
       AbstractTypeArguments::Handle(arguments());
   return args.IsNull() || args.IsInstantiated();
 }
 
 
 RawAbstractType* Type::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments,
     Error* malformed_error) const {
-  ASSERT(IsFinalized());
+  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);
   // Note that the type class has to be resolved at this time, but not
@@ skipping 11 matching lines @@
 
 
 bool Type::Equals(const Instance& other) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsType()) {
     return false;
   }
   const Type& other_type = Type::Cast(other);
-  ASSERT(IsFinalized() && other_type.IsFinalized());
+  ASSERT(IsResolved() && other_type.IsResolved());
   if (IsMalformed() || other_type.IsMalformed()) {
     return false;
   }
   if (type_class() != other_type.type_class()) {
     return false;
   }
+  if (!IsFinalized() || !other_type.IsFinalized()) {
+    return false;
+  }
   return AbstractTypeArguments::AreEqual(
       AbstractTypeArguments::Handle(arguments()),
       AbstractTypeArguments::Handle(other_type.arguments()));
 }
 
 
 RawAbstractType* Type::Canonicalize() const {
   ASSERT(IsFinalized());
   if (IsCanonical() || IsMalformed()) {
     ASSERT(IsMalformed() || AbstractTypeArguments::Handle(arguments()).IsOld());
@@ skipping 189 matching lines @@
 }
 
 
 RawAbstractType* TypeParameter::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments,
     Error* malformed_error) const {
   ASSERT(IsFinalized());
   if (instantiator_type_arguments.IsNull()) {
     return Type::DynamicType();
   }
-  // Bound checks should never appear in the instantiator type arguments.
-  ASSERT(!AbstractType::Handle(
-      instantiator_type_arguments.TypeAt(index())).IsBoundedType());
-  return instantiator_type_arguments.TypeAt(index());
+  // 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);
+    ASSERT(!bounded_type.IsInstantiated());
+    ASSERT(AbstractType::Handle(bounded_type.bound()).IsInstantiated());
+    type_arg = bounded_type.InstantiateFrom(AbstractTypeArguments::Handle(),
+                                            malformed_error);
+  }
+  return type_arg.raw();
 }
 
 
-void TypeParameter::CheckBound(const AbstractType& bounded_type,
+bool TypeParameter::CheckBound(const AbstractType& bounded_type,
                                const AbstractType& upper_bound,
                                Error* malformed_error) const {
-  ASSERT(malformed_error->IsNull());
+  ASSERT((malformed_error == NULL) || malformed_error->IsNull());
   ASSERT(bounded_type.IsFinalized());
   ASSERT(upper_bound.IsFinalized());
   ASSERT(!bounded_type.IsMalformed());
-  if (bounded_type.IsSubtypeOf(upper_bound, malformed_error) ||
-      !malformed_error->IsNull()) {
-    return;
+  if (bounded_type.IsSubtypeOf(upper_bound, malformed_error)) {
+    return true;
   }
-  // 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,
-      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());
+  if ((malformed_error != NULL) && malformed_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,
+        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());
+  }
+  return false;
 }
 
 
 intptr_t TypeParameter::Hash() const {
   ASSERT(IsFinalized());
   uword result = 0;
   result += Class::Handle(parameterized_class()).id();
   // Do not include the hash of the bound, which could lead to cycles.
   result <<= index();
   return FinalizeHash(result);
@@ skipping 3219 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart