Do not require upper bounds to be resolved and finalized before comparing them

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 1986 matching lines @@
 }
 
 
 bool AbstractType::Equals(const AbstractType& other) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
+bool AbstractType::IsIdentical(const AbstractType& other) const {
+  // AbstractType is an abstract class.
+  UNREACHABLE();
+  return false;
+}
+
+
 RawAbstractType* AbstractType::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 RawAbstractType* AbstractType::Canonicalize() const {
   // AbstractType is an abstract class.
@@ skipping 285 matching lines @@
 
 RawUnresolvedClass* Type::unresolved_class() const {
   ASSERT(!HasResolvedTypeClass());
   UnresolvedClass& unresolved_class = UnresolvedClass::Handle();
   unresolved_class ^= raw_ptr()->type_class_;
   ASSERT(!unresolved_class.IsNull());
   return unresolved_class.raw();
 }
 
 
+RawString* Type::TypeClassName() const {
+  if (HasResolvedTypeClass()) {
+    const Class& cls = Class::Handle(type_class());
+    return cls.Name();
+  } else {
+    const UnresolvedClass& cls = UnresolvedClass::Handle(unresolved_class());
+    return cls.Name();
+  }
+}
+
+
 RawAbstractTypeArguments* Type::arguments() const {
   return raw_ptr()->arguments_;
 }
 
 
 bool Type::IsInstantiated() const {
   const AbstractTypeArguments& args =
       AbstractTypeArguments::Handle(arguments());
   return args.IsNull() || args.IsInstantiated();
 }
@@ skipping 18 matching lines @@
 
 
 bool Type::Equals(const AbstractType& other) const {
   ASSERT(IsFinalized() && other.IsFinalized());
   if (raw() == other.raw()) {
     return true;
   }
   if (IsMalformed() || !other.IsType() || other.IsMalformed()) {
     return false;
   }
-  Type& other_parameterized_type = Type::Handle();
-  other_parameterized_type ^= other.raw();
-  if (type_class() != other_parameterized_type.type_class()) {
+  Type& other_type = Type::Handle();
+  other_type ^= other.raw();
+  if (type_class() != other_type.type_class()) {
     return false;
   }
   return AbstractTypeArguments::AreEqual(
       AbstractTypeArguments::Handle(arguments()),
       AbstractTypeArguments::Handle(other.arguments()));
 }
 
 
+bool Type::IsIdentical(const AbstractType& other) const {
+  if (raw() == other.raw()) {
+    return true;
+  }
+  if (!other.IsType()) {
+    return false;
+  }
+  Type& other_type = Type::Handle();
+  other_type ^= other.raw();
+  // Both type classes may not be resolved yet.
+  String& name = String::Handle(TypeClassName());
+  String& other_name = String::Handle(other_type.TypeClassName());
+  if (!name.Equals(other_name)) {
+    return false;
+  }
+  return AbstractTypeArguments::AreIdentical(
+      AbstractTypeArguments::Handle(arguments()),
+      AbstractTypeArguments::Handle(other.arguments()));
+}
+
+
 RawAbstractType* Type::Canonicalize() const {
   ASSERT(IsFinalized());
   const Class& cls = Class::Handle(type_class());
   Array& canonical_types = Array::Handle(cls.canonical_types());
   if (canonical_types.IsNull()) {
     // Types defined in the VM isolate are canonicalized via the object store.
     return this->raw();
   }
   if (!IsCanonical()) {
     const intptr_t canonical_types_len = canonical_types.Length();
@@ skipping 137 matching lines @@
   }
   if (Index() != other_type_param.Index()) {
     return false;
   }
   const String& name = String::Handle(Name());
   const String& other_type_param_name = String::Handle(other_type_param.Name());
   return name.Equals(other_type_param_name);
 }
 
 
+bool TypeParameter::IsIdentical(const AbstractType& other) const {
+  if (raw() == other.raw()) {
+    return true;
+  }
+  if (!other.IsTypeParameter()) {
+    return false;
+  }
+  TypeParameter& other_type_param = TypeParameter::Handle();
+  other_type_param ^= other.raw();
+  // Both type parameters may have different type_class and their index may be
+  // different after finalization, which is OK. Do not check.
+  String& name = String::Handle(Name());
+  String& other_name = String::Handle(other_type_param.Name());
+  return name.Equals(other_name);
+}
+
+
 void TypeParameter::set_parameterized_class(const Class& value) const {
   // Set value may be null.
   StorePointer(&raw_ptr()->parameterized_class_, value.raw());
 }
 
 
 void TypeParameter::set_index(intptr_t value) const {
   ASSERT(value >= 0);
   raw_ptr()->index_ = value;
 }
@@ skipping 221 matching lines @@
   if (arguments.IsNull()) {
     return other_arguments.IsDynamicTypes(false, other_arguments.Length());
   }
   if (other_arguments.IsNull()) {
     return arguments.IsDynamicTypes(false, arguments.Length());
   }
   return arguments.Equals(other_arguments);
 }
 
 
+bool AbstractTypeArguments::AreIdentical(
+    const AbstractTypeArguments& arguments,
+    const AbstractTypeArguments& other_arguments) {
+  if (arguments.raw() == other_arguments.raw()) {
+    return true;
+  }
+  if (arguments.IsNull() || other_arguments.IsNull()) {
+    return false;
+  }
+  intptr_t num_types = arguments.Length();
+  if (num_types != other_arguments.Length()) {
+    return false;
+  }
+  AbstractType& type = AbstractType::Handle();
+  AbstractType& other_type = AbstractType::Handle();
+  for (intptr_t i = 0; i < num_types; i++) {
+    type ^= arguments.TypeAt(i);
+    ASSERT(!type.IsNull());
+    other_type ^= other_arguments.TypeAt(i);
+    if (!type.IsIdentical(other_type)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+
 RawAbstractTypeArguments* AbstractTypeArguments::InstantiateFrom(
     const AbstractTypeArguments& instantiator_type_arguments) const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
 bool AbstractTypeArguments::IsDynamicTypes(bool raw_instantiated,
                                            intptr_t len) const {
@@ skipping 204 matching lines @@
     type = TypeAt(i);
     if (!type.IsInstantiated()) {
       type = type.InstantiateFrom(instantiator_type_arguments);
     }
     instantiated_array.SetTypeAt(i, type);
   }
   return instantiated_array.raw();
 }
 
 
-bool TypeArguments::AreIdenticalTypeParameters(
-    const TypeArguments& arguments,
-    const TypeArguments& other_arguments) {
-  if (arguments.raw() == other_arguments.raw()) {
-    return true;
-  }
-  if (arguments.IsNull() || other_arguments.IsNull()) {
-    return false;
-  }
-  intptr_t num_types = arguments.Length();
-  if (num_types != other_arguments.Length()) {
-    return false;
-  }
-  TypeParameter& type = TypeParameter::Handle();
-  TypeParameter& other_type = TypeParameter::Handle();
-  String& name = String::Handle();
-  String& other_name = String::Handle();
-  for (intptr_t i = 0; i < num_types; i++) {
-    type ^= arguments.TypeAt(i);
-    other_type ^= other_arguments.TypeAt(i);
-    if (type.raw() == other_type.raw()) {
-      continue;
-    }
-    // Both type parameters may have different type_class and their index may be
-    // different after finalization, which is OK. Do not check.
-    name = type.Name();
-    other_name = other_type.Name();
-    if (!name.Equals(other_name)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-
 RawTypeArguments* TypeArguments::New(intptr_t len) {
   if ((len < 0) || (len > kMaxTypes)) {
     // TODO(iposva): Should we throw an illegal parameter exception?
     UNIMPLEMENTED();
     return null();
   }
 
   const Class& type_arguments_class =
       Class::Handle(Object::type_arguments_class());
   TypeArguments& result = TypeArguments::Handle();
@@ skipping 6018 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