Replace calls to Class::IsParameterized() by either

runtime/vm/object.h

 // Copyright (c) 2011, 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
@@ skipping 407 matching lines @@
 
   // If this class is parameterized, each instance has a type_arguments field.
   intptr_t NumTypeArguments() const;
   static const intptr_t kNoTypeArguments = -1;
   intptr_t type_arguments_instance_field_offset() const {
     ASSERT(is_finalized() || is_prefinalized());
     return raw_ptr()->type_arguments_instance_field_offset_;
   }
   void set_type_arguments_instance_field_offset(intptr_t value) const {
     raw_ptr()->type_arguments_instance_field_offset_ = value;
   }

[siva, 2011/10/18 05:06:19]

The old comment says IsParametrized is more efficient than calling
NumTypeArguments(), if that is valid then will we be regressing?

Also I am wondering if it would make the code more
readable if you continued to have IsParameterized and
implemented it as:
bool IsParameterized() const {
  return NumTypeArguments() > 0;
}

[regis, 2011/10/18 17:28:21]

Yes, I think I should reintroduce a helper function for efficiency and
readability. But I need to pick a better name, since this one was not clear.

-  bool IsParameterized() const {
-    if (is_finalized() || is_prefinalized()) {
-      // More efficient than calling NumTypeArguments().
-      return type_arguments_instance_field_offset() != kNoTypeArguments;
-    } else {
-      return NumTypeArguments() > 0;
-    }
-  }
 
   // The super type of this class, Object type if not explicitly specified.
   RawType* super_type() const { return raw_ptr()->super_type_; }
   void set_super_type(const Type& value) const;
 
   // Asserts that the class of the super type has been resolved.
   RawClass* SuperClass() const;
 
   // The factory type of this interface, null if not specified.
   RawType* factory_type() const { return raw_ptr()->factory_type_; }
@@ skipping 2429 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_