Fix an F-bounded quantification bug (issue 9291).

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 9208 matching lines @@
       if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
         // Most probably a malformed type. Do not fill up with "dynamic",
         // but use actual vector.
         num_type_params = num_args;
       } else {
         ASSERT(num_args == 0);  // Type is raw.
         // No need to fill up with "dynamic".
         num_type_params = 0;
       }
     } else {
-      first_type_param_index = num_args - num_type_params;
+      // The actual type argument vector can be longer than necessary, because
+      // of type optimizations.
+      if (IsFinalized() && cls.is_finalized()) {
+        first_type_param_index = cls.NumTypeArguments() - num_type_params;
+      } else {
+        first_type_param_index = num_args - num_type_params;
+      }
     }
     if (cls.IsSignatureClass()) {
       // We may be reporting an error about a malformed function type. In that
       // case, avoid instantiating the signature, since it may lead to cycles.
       if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
         return class_name.raw();
       }
       // In order to avoid cycles, print the name of a typedef (non-canonical
       // signature class) as a regular, possibly parameterized, class.
       if (cls.IsCanonicalSignatureClass()) {
         const Function& signature_function = Function::Handle(
             cls.signature_function());
-        // Signature classes have no super type.
-        ASSERT(first_type_param_index == 0);
+        // Signature classes have no super type, however, they take as many
+        // type arguments as the owner class of their signature function (if it
+        // non static and generic, see Class::NumTypeArguments()). Therefore,

[srdjan, 2013/03/27 20:38:13]

s/if it non static/if it is non static/

[regis, 2013/03/27 20:41:42]

Done.

+        // first_type_param_index may be greater than 0 here.
         return signature_function.InstantiatedSignatureFrom(args,
                                                             name_visibility);
       }
     }
   } else {
     const UnresolvedClass& cls = UnresolvedClass::Handle(unresolved_class());
     class_name = cls.Name();
     num_type_params = num_args;
     first_type_param_index = 0;
   }
@@ skipping 334 matching lines @@
   ASSERT(IsFinalized());
   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
+  // necessarily finalized yet. We may be checking bounds at compile time.
   const Class& cls = Class::Handle(type_class());
-  ASSERT(cls.is_finalized());
   // 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();
   return instantiated_type.raw();
 }
 
@@ skipping 164 matching lines @@
 }
 
 
 void TypeParameter::set_is_finalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawTypeParameter::kFinalizedUninstantiated);
 }
 
 
 bool TypeParameter::Equals(const Instance& other) const {
-  ASSERT(IsFinalized());
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
   const TypeParameter& other_type_param = TypeParameter::Cast(other);
   ASSERT(other_type_param.IsFinalized());
   if (parameterized_class() != other_type_param.parameterized_class()) {
     return false;
   }
+  if (IsFinalized() != other_type_param.IsFinalized()) {
+    return false;
+  }
   if (index() != other_type_param.index()) {
     return false;
   }
   return true;
 }
 
 
 void TypeParameter::set_parameterized_class(const Class& value) const {
   // Set value may be null.
   StorePointer(&raw_ptr()->parameterized_class_, value.raw());
@@ skipping 3841 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart