Cache number of type arguments in class object instead of recalculating it.

runtime/vm/code_generator.cc

 // Copyright (c) 2013, 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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 93 matching lines @@
 
 // Allocate a new object.
 // Arg0: class of the object that needs to be allocated.
 // Arg1: type arguments of the object that needs to be allocated.
 // Arg2: type arguments of the instantiator or kNoInstantiator.
 // Return value: newly allocated object.
 DEFINE_RUNTIME_ENTRY(AllocateObject, 3) {
   const Class& cls = Class::CheckedHandle(arguments.ArgAt(0));
   const Instance& instance = Instance::Handle(Instance::New(cls));
   arguments.SetReturn(instance);
-  if (!cls.HasTypeArguments()) {
+  if (cls.NumTypeArguments() == 0) {
     // No type arguments required for a non-parameterized type.
     ASSERT(Instance::CheckedHandle(arguments.ArgAt(1)).IsNull());
     return;
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   // If no instantiator is provided, set the type arguments and return.
   if (Object::Handle(arguments.ArgAt(2)).IsSmi()) {
     ASSERT(Smi::CheckedHandle(arguments.ArgAt(2)).Value() ==
            StubCode::kNoInstantiator);
@@ skipping 33 matching lines @@
 // arguments are within the declared bounds or throw a dynamic type error.
 // Arg0: class of the object that needs to be allocated.
 // Arg1: type arguments of the object that needs to be allocated.
 // Arg2: type arguments of the instantiator or kNoInstantiator.
 // Return value: newly allocated object.
 DEFINE_RUNTIME_ENTRY(AllocateObjectWithBoundsCheck, 3) {
   ASSERT(FLAG_enable_type_checks);
   const Class& cls = Class::CheckedHandle(arguments.ArgAt(0));
   const Instance& instance = Instance::Handle(Instance::New(cls));
   arguments.SetReturn(instance);
-  ASSERT(cls.HasTypeArguments());
+  ASSERT(cls.NumTypeArguments() > 0);
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   if (Object::Handle(arguments.ArgAt(2)).IsSmi()) {
     ASSERT(Smi::CheckedHandle(arguments.ArgAt(2)).Value() ==
            StubCode::kNoInstantiator);
     // Unless null (for a raw type), the type argument vector may be longer than
     // necessary due to a type optimization reusing the type argument vector of
     // the instantiator.
     ASSERT(type_arguments.IsNull() ||
            (type_arguments.IsInstantiated() &&
@@ skipping 186 matching lines @@
   OS::PrintErr(" -> Function %s\n", function.ToFullyQualifiedCString());
 }
 
 
 // Converts InstantiatedTypeArguments to TypeArguments and stores it
 // into the instance. The assembly code can handle only type arguments of
 // class TypeArguments. Because of the overhead, do it only when needed.
 // Return true if type arguments have been replaced, false otherwise.
 static bool OptimizeTypeArguments(const Instance& instance) {
   const Class& type_class = Class::ZoneHandle(instance.clazz());
-  if (!type_class.HasTypeArguments()) {
+  if (type_class.NumTypeArguments() == 0) {
     return false;
   }
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(instance.GetTypeArguments());
   if (type_arguments.IsNull()) {
     return false;
   }
   bool replaced = false;
   if (type_arguments.IsInstantiatedTypeArguments()) {
     AbstractTypeArguments& uninstantiated = AbstractTypeArguments::Handle();
@@ skipping 45 matching lines @@
   if (new_cache.IsNull()) return;
   // Instantiator type arguments may be canonicalized later.
   AbstractTypeArguments& instantiator_type_arguments =
       AbstractTypeArguments::Handle(incoming_instantiator_type_arguments.raw());
   AbstractTypeArguments& instance_type_arguments =
       AbstractTypeArguments::Handle();
   const Class& instance_class = Class::Handle(instance.clazz());
 
   // Canonicalize type arguments.
   bool type_arguments_replaced = false;
-  if (instance_class.HasTypeArguments()) {
+  if (instance_class.NumTypeArguments() > 0) {
     // Canonicalize type arguments.
     type_arguments_replaced = OptimizeTypeArguments(instance);
     instance_type_arguments = instance.GetTypeArguments();
   }
   if (!instantiator.IsNull()) {
     if (OptimizeTypeArguments(instantiator)) {
       type_arguments_replaced = true;
     }
     instantiator_type_arguments = instantiator.GetTypeArguments();
   }
@@ skipping 1250 matching lines @@
   field.UpdateCid(cid);
   intptr_t list_length = Field::kNoFixedLength;
   if ((field.guarded_cid() != kDynamicCid) &&
       field.is_final() && RawObject::IsBuiltinListClassId(cid)) {
     list_length = GetListLength(value);
   }
   field.UpdateLength(list_length);
 }
 
 }  // namespace dart