Further improve type optimization reusing the type argument vector of the

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 2601 matching lines @@
 }
 
 
 bool AbstractTypeArguments::IsUninstantiatedIdentity() const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
+bool AbstractTypeArguments::CanShareInstantiatorTypeArguments(
+      const Class& instantiator_class) const {
+  // AbstractTypeArguments is an abstract class.
+  UNREACHABLE();
+  return false;
+}
+
+
 bool AbstractTypeArguments::IsBounded() const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 static intptr_t FinalizeHash(uword hash) {
   hash += hash << 3;
   hash ^= hash >> 11;
@@ skipping 209 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 
 bool TypeArguments::IsUninstantiatedIdentity() const {
   ASSERT(!IsInstantiated());
   AbstractType& type = AbstractType::Handle();
-  intptr_t num_types = Length();
+  const intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (!type.IsTypeParameter()) {
       return false;
     }
     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.IsResolved());
     if (!bound.IsObjectType() && !bound.IsDynamicType()) {
       return false;
     }
   }
   return true;
+  // Note that it is not necessary to verify at runtime that the instantiator
+  // type vector is long enough, since this uninstantiated vector contains as
+  // many different type parameters as it is long.
+}
+
+
+bool TypeArguments::CanShareInstantiatorTypeArguments(
+      const Class& instantiator_class) const {
+  ASSERT(!IsInstantiated());
+  const intptr_t num_instantiator_type_args =
+      instantiator_class.NumTypeArguments();
+  const intptr_t num_instantiator_type_params =
+      instantiator_class.NumTypeParameters();
+  const intptr_t num_super_instantiator_type_args =
+      num_instantiator_type_args - num_instantiator_type_params;
+  const intptr_t num_type_args = Length();
+  // As a first requirement in order to share the instantiator type argument
+  // vector, this type argument vector must refer to the type parameters of the
+  // instantiator class in declaration order. It does not need to contain all
+  // type parameters.
+  if (num_type_args < num_super_instantiator_type_args) {
+    return false;
+  }
+  AbstractType& type_arg = AbstractType::Handle();
+  for (intptr_t i = num_super_instantiator_type_args; i < num_type_args; i++) {
+    type_arg = TypeAt(i);
+    if (!type_arg.IsTypeParameter()) {
+      return false;
+    }
+    const TypeParameter& type_param = TypeParameter::Cast(type_arg);
+    ASSERT(type_param.IsFinalized());
+    if ((type_param.index() != i)) {
+      return false;
+    }
+  }
+  // As a second requirement, the type arguments corresponding to the super type
+  // must be identical.
+  if (num_super_instantiator_type_args == 0) {
+    return true;
+  }
+  AbstractType& super_type = AbstractType::Handle(
+      instantiator_class.super_type());
+  const AbstractTypeArguments& super_type_args = AbstractTypeArguments::Handle(
+      super_type.arguments());
+  if (super_type_args.IsNull()) {
+    return false;
+  }
+  AbstractType& super_type_arg = AbstractType::Handle();
+  for (intptr_t i = 0; i < num_super_instantiator_type_args; i++) {
+    type_arg = TypeAt(i);
+    super_type_arg = super_type_args.TypeAt(i);
+    if (!type_arg.Equals(super_type_arg)) {
+      return false;
+    }
+  }
+  return true;
 }
 
 
 bool TypeArguments::IsBounded() const {
   AbstractType& type = AbstractType::Handle();
   intptr_t num_types = Length();
   for (intptr_t i = 0; i < num_types; i++) {
     type = TypeAt(i);
     if (type.IsBoundedType()) {
       return true;
@@ skipping 10257 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart