Improve type optimization reusing the type argument vector of the instantiator

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 9005 matching lines @@
   }
   const Class& cls = Class::Handle(clazz());
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
   const intptr_t num_type_arguments = cls.NumTypeArguments();
   if (num_type_arguments > 0) {
     type_arguments = GetTypeArguments();
     if (!type_arguments.IsNull() && !type_arguments.IsCanonical()) {
       type_arguments = type_arguments.Canonicalize();
       SetTypeArguments(type_arguments);
     }
-    // Verify that the number of type arguments in the instance matches the
-    // number of type arguments expected by the instance class.
+    // The number of type arguments in the instance must be greater or equal to
+    // the number of type arguments expected by the instance class.
     // A discrepancy is allowed for closures, which borrow the type argument
     // vector of their instantiator, which may be of a subclass of the class
     // defining the closure. Truncating the vector to the correct length on
     // instantiation is unnecessary. The vector may therefore be longer.
+    // 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) ||
-           (cls.IsSignatureClass() &&
-            (type_arguments.Length() > num_type_arguments)));
+           (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()) {
       ASSERT(FLAG_enable_type_checks);
       return false;
@@ skipping 4122 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart