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

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 463 matching lines @@
 
     Class fake;
     // Initialization from Class::New<Class>.
     // Directly set raw_ to break a circular dependency: SetRaw will attempt
     // to lookup class class in the class table where it is not registered yet.
     cls.raw_ = class_class_;
     cls.set_handle_vtable(fake.vtable());
     cls.set_instance_size(Class::InstanceSize());
     cls.set_next_field_offset(Class::InstanceSize());
     cls.set_id(Class::kClassId);
-    cls.raw_ptr()->state_bits_ = 0;
+    cls.set_state_bits(0);
     cls.set_is_finalized();
     cls.set_is_type_finalized();
-    cls.raw_ptr()->type_arguments_field_offset_in_words_ =
-        Class::kNoTypeArguments;
-    cls.raw_ptr()->num_native_fields_ = 0;
+    cls.set_type_arguments_field_offset_in_words(Class::kNoTypeArguments);
+    cls.set_num_type_arguments(0);
+    cls.set_num_own_type_arguments(0);
+    cls.set_num_native_fields(0);
     cls.InitEmptyFields();
     isolate->RegisterClass(cls);
   }
 
   // Allocate and initialize the null class.
   cls = Class::New<Instance>(kNullCid);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   isolate->object_store()->set_null_class(cls);
 
   // Allocate and initialize the free list element class.
   cls = Class::New<FreeListElement::FakeInstance>(kFreeListElement);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   cls.set_is_finalized();
   cls.set_is_type_finalized();
 
   // Allocate and initialize the sentinel values of Null class.
   {
     *sentinel_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
 
     *transition_sentinel_ ^=
         Object::Allocate(kNullCid, Instance::InstanceSize(), Heap::kOld);
@@ skipping 98 matching lines @@
   cls = Class::New<UnwindError>();
   unwind_error_class_ = cls.raw();
 
   ASSERT(class_class() != null_);
 
   // Pre-allocate classes in the vm isolate so that we can for example create a
   // symbol table and populate it with some frequently used strings as symbols.
   cls = Class::New<Array>();
   isolate->object_store()->set_array_class(cls);
   cls.set_type_arguments_field_offset(Array::type_arguments_offset());
+  cls.set_num_type_arguments(1);
+  cls.set_num_own_type_arguments(1);
   cls = Class::New<Array>(kImmutableArrayCid);
   isolate->object_store()->set_immutable_array_class(cls);
   cls.set_type_arguments_field_offset(Array::type_arguments_offset());
+  cls.set_num_type_arguments(1);
+  cls.set_num_own_type_arguments(1);
   cls = Class::NewStringClass(kOneByteStringCid);
   isolate->object_store()->set_one_byte_string_class(cls);
   cls = Class::NewStringClass(kTwoByteStringCid);
   isolate->object_store()->set_two_byte_string_class(cls);
 
   // Allocate and initialize the empty_array instance.
   {
     uword address = heap->Allocate(Array::InstanceSize(0), Heap::kOld);
     InitializeObject(address, kArrayCid, Array::InstanceSize(0));
     Array::initializeHandle(
         empty_array_,
         reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     empty_array_->raw()->ptr()->length_ = Smi::New(0);
   }
 
   cls = Class::New<Instance>(kDynamicCid);
+  cls.set_is_abstract();
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
+  cls.set_is_type_finalized();
   cls.set_is_finalized();
-  cls.set_is_type_finalized();
-  cls.set_is_abstract();
   dynamic_class_ = cls.raw();
 
   cls = Class::New<Instance>(kVoidCid);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
+  cls.set_is_type_finalized();
   cls.set_is_finalized();
-  cls.set_is_type_finalized();
   void_class_ = cls.raw();
 
   cls = Class::New<Type>();
+  cls.set_is_type_finalized();
   cls.set_is_finalized();
-  cls.set_is_type_finalized();
   isolate->object_store()->set_type_class(cls);
 
   cls = dynamic_class_;
   dynamic_type_ = Type::NewNonParameterizedType(cls);
 
   cls = void_class_;
   void_type_ = Type::NewNonParameterizedType(cls);
 
   // Allocate and initialize singleton true and false boolean objects.
   cls = Class::New<Bool>();
@@ skipping 195 matching lines @@
   // All RawArray fields will be initialized to an empty array, therefore
   // initialize array class first.
   cls = Class::New<Array>();
   object_store->set_array_class(cls);
 
   // Array and ImmutableArray are the only VM classes that are parameterized.
   // Since they are pre-finalized, CalculateFieldOffsets() is not called, so we
   // need to set the offset of their type_arguments_ field, which is explicitly
   // declared in RawArray.
   cls.set_type_arguments_field_offset(Array::type_arguments_offset());
+  cls.set_num_type_arguments(1);
+  cls.set_num_own_type_arguments(1);
 
   // Set up the growable object array class (Has to be done after the array
   // class is setup as one of its field is an array object).
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
   cls.set_type_arguments_field_offset(
       GrowableObjectArray::type_arguments_offset());
+  cls.set_num_type_arguments(1);
+  cls.set_num_own_type_arguments(1);
 
   // canonical_type_arguments_ are Smi terminated.
   // Last element contains the count of used slots.
   const intptr_t kInitialCanonicalTypeArgumentsSize = 4;
   array = Array::New(kInitialCanonicalTypeArgumentsSize + 1);
   array.SetAt(kInitialCanonicalTypeArgumentsSize, Smi::Handle(Smi::New(0)));
   object_store->set_canonical_type_arguments(array);
 
   // Setup type class early in the process.
   cls = Class::New<Type>();
@@ skipping 53 matching lines @@
   type ^= type.Canonicalize();
   object_store->set_array_type(type);
 
   cls = object_store->growable_object_array_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::_GrowableList(), core_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<Array>(kImmutableArrayCid);
   object_store->set_immutable_array_class(cls);
   cls.set_type_arguments_field_offset(Array::type_arguments_offset());
+  cls.set_num_type_arguments(1);
+  cls.set_num_own_type_arguments(1);
   ASSERT(object_store->immutable_array_class() != object_store->array_class());
   cls.set_is_prefinalized();
   RegisterPrivateClass(cls, Symbols::_ImmutableList(), core_lib);
   pending_classes.Add(cls);
 
   cls = object_store->one_byte_string_class();  // Was allocated above.
   RegisterPrivateClass(cls, Symbols::OneByteString(), core_lib);
   pending_classes.Add(cls);
 
   cls = object_store->two_byte_string_class();  // Was allocated above.
@@ skipping 23 matching lines @@
 
   // Initialize the base interfaces used by the core VM classes.
 
   // Allocate and initialize the pre-allocated classes in the core library.
   // The script and token index of these pre-allocated classes is set up in
   // the parser when the corelib script is compiled (see
   // Parser::ParseClassDefinition).
   cls = Class::New<Instance>(kInstanceCid);
   object_store->set_object_class(cls);
   cls.set_name(Symbols::Object());
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   core_lib.AddClass(cls);
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
   RegisterClass(cls, Symbols::Bool(), core_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<Instance>(kNullCid);
+  object_store->set_null_class(cls);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
-  object_store->set_null_class(cls);
   RegisterClass(cls, Symbols::Null(), core_lib);
   pending_classes.Add(cls);
 
   cls = object_store->type_class();
   RegisterPrivateClass(cls, Symbols::Type(), core_lib);
   pending_classes.Add(cls);
 
   cls = object_store->type_parameter_class();
   RegisterPrivateClass(cls, Symbols::TypeParameter(), core_lib);
   pending_classes.Add(cls);
@@ skipping 26 matching lines @@
   RegisterPrivateClass(cls, Symbols::_Bigint(), core_lib);
   pending_classes.Add(cls);
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
   RegisterPrivateClass(cls, Symbols::_Double(), core_lib);
   pending_classes.Add(cls);
 
   // Abstract super class for all signature classes.
   cls = Class::New<Instance>(kIllegalCid);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   RegisterPrivateClass(cls, Symbols::FunctionImpl(), core_lib);
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_impl_type(type);
 
   cls = Class::New<WeakProperty>();
   object_store->set_weak_property_class(cls);
   RegisterPrivateClass(cls, Symbols::_WeakProperty(), core_lib);
 
@@ skipping 67 matching lines @@
   // Register Float32x4 and Uint32x4 in the object store.
   cls = Class::New<Float32x4>();
   object_store->set_float32x4_class(cls);
   RegisterPrivateClass(cls, Symbols::_Float32x4(), lib);
   cls = Class::New<Uint32x4>();
   object_store->set_uint32x4_class(cls);
   RegisterPrivateClass(cls, Symbols::_Uint32x4(), lib);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Float32x4(), lib);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_float32x4_type(type);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Uint32x4(), lib);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_uint32x4_type(type);
 
   object_store->set_typed_data_classes(typed_data_classes);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   type = object_store->object_type();
   cls.set_super_type(type);
 
   // Abstract class that represents the Dart class Function.
   cls = Class::New<Instance>(kIllegalCid);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   RegisterClass(cls, Symbols::Function(), core_lib);
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_type(type);
 
   cls = Class::New<Number>();
   RegisterClass(cls, Symbols::Number(), core_lib);
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_number_type(type);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Int(), core_lib);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_int_type(type);
 
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, Symbols::Double(), core_lib);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_double_type(type);
 
   name = Symbols::New("String");
   cls = Class::New<Instance>(kIllegalCid);
   RegisterClass(cls, name, core_lib);
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   cls.set_is_prefinalized();
   pending_classes.Add(cls);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_string_type(type);
 
   cls = object_store->bool_class();
   type = Type::NewNonParameterizedType(cls);
   object_store->set_bool_type(type);
 
   cls = object_store->smi_class();
@@ skipping 412 matching lines @@
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::InstanceSize());
   ASSERT((FakeObject::kClassId != kInstanceCid));
   result.set_id(FakeObject::kClassId);
-  result.raw_ptr()->state_bits_ = 0;
+  result.set_state_bits(0);
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
   result.set_is_prefinalized();
-  result.raw_ptr()->type_arguments_field_offset_in_words_ = kNoTypeArguments;
-  result.raw_ptr()->num_native_fields_ = 0;
-  result.raw_ptr()->token_pos_ = Scanner::kDummyTokenIndex;
+  result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
+  result.set_num_type_arguments(0);
+  result.set_num_own_type_arguments(0);
+  result.set_num_native_fields(0);
+  result.set_token_pos(Scanner::kDummyTokenIndex);
   result.InitEmptyFields();
   Isolate::Current()->RegisterClass(result);
   return result.raw();
 }
 
 
+static RawError* FormatError(const Error& prev_error,
+                             const Script& script,
+                             intptr_t token_pos,
+                             const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  if (prev_error.IsNull()) {
+    return Parser::FormatError(script, token_pos, "Error", format, args);
+  } else {
+    return Parser::FormatErrorWithAppend(prev_error, script, token_pos,
+                                         "Error", format, args);
+  }
+}
+
+
+static void ReportTooManyTypeArguments(const Class& cls) {
+  const Error& error = Error::Handle(
+      FormatError(Error::Handle(),  // No previous error.
+                  Script::Handle(cls.script()), cls.token_pos(),
+                  "too many type parameters declared in class '%s' or in its "
+                  "super classes",
+                  String::Handle(cls.Name()).ToCString()));
+  Isolate::Current()->long_jump_base()->Jump(1, error);
+  UNREACHABLE();
+}
+
+
+void Class::set_num_type_arguments(intptr_t value) const {
+  if (!Utils::IsInt(16, value)) {
+    ReportTooManyTypeArguments(*this);
+  }
+  raw_ptr()->num_type_arguments_ = value;
+}
+
+
+void Class::set_num_own_type_arguments(intptr_t value) const {
+  if (!Utils::IsInt(16, value)) {
+    ReportTooManyTypeArguments(*this);
+  }
+  raw_ptr()->num_own_type_arguments_ = value;
+}
+
+
 // Initialize class fields of type Array with empty array.
 void Class::InitEmptyFields() {
   if (Object::empty_array().raw() == Array::null()) {
     // The empty array has not been initialized yet.
     return;
   }
   StorePointer(&raw_ptr()->interfaces_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->constants_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->canonical_types_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->functions_, Object::empty_array().raw());
@@ skipping 107 matching lines @@
   }
   if (type_parameters() == TypeArguments::null()) {
     return 0;
   }
   const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   return type_params.Length();
 }
 
 
 intptr_t Class::NumOwnTypeArguments() const {
+  // Return cached value if already calculated.
+  if (num_own_type_arguments() != kUnknownNumTypeArguments) {
+    return num_own_type_arguments();
+  }
   Isolate* isolate = Isolate::Current();
   const intptr_t num_type_params = NumTypeParameters();
   if (!FLAG_overlap_type_arguments ||
       (num_type_params == 0) ||
       (super_type() == AbstractType::null()) ||
       (super_type() == isolate->object_store()->object_type())) {
+    set_num_own_type_arguments(num_type_params);
     return num_type_params;
   }
   ASSERT(!IsMixinApplication() || is_mixin_type_applied());
   const AbstractType& sup_type = AbstractType::Handle(isolate, super_type());
   ASSERT(sup_type.IsResolved());
   const AbstractTypeArguments& sup_type_args =
       AbstractTypeArguments::Handle(isolate, sup_type.arguments());
   if (sup_type_args.IsNull()) {
     // The super type is raw or the super class is non generic.
     // In either case, overlapping is not possible.
+    set_num_own_type_arguments(num_type_params);
     return num_type_params;
   }
   const intptr_t num_sup_type_args = sup_type_args.Length();
   // At this point, the super type may or may not be finalized. In either case,
   // the result of this function must remain the same.
   // The value of num_sup_type_args may increase when the super type is
   // finalized, but the last num_sup_type_args type arguments will not be
   // modified by finalization, only shifted to higher indices in the vector.
   // They may however get wrapped in a BoundedType, which we skip.
   const AbstractTypeArguments& type_params =
@@ skipping 19 matching lines @@
           num_sup_type_args - num_overlapping_type_args + i);
       // BoundedType can nest in case the finalized super type has bounded type
       // arguments that overlap multiple times in its own super class chain.
       while (sup_type_arg.IsBoundedType()) {
         sup_type_arg = BoundedType::Cast(sup_type_arg).type();
       }
       if (!type_param.Equals(sup_type_arg)) break;
     }
     if (i == num_overlapping_type_args) {
       // Overlap found.
+      set_num_own_type_arguments(num_type_params - num_overlapping_type_args);
       return num_type_params - num_overlapping_type_args;
     }
   }
   // No overlap found.
+  set_num_own_type_arguments(num_type_params);
   return num_type_params;
 }
 
 
 intptr_t Class::NumTypeArguments() const {
+  // Return cached value if already calculated.
+  if (num_type_arguments() != kUnknownNumTypeArguments) {
+    return num_type_arguments();
+  }
   // To work properly, this call requires the super class of this class to be
   // resolved, which is checked by the type_class() call on the super type.
   // Note that calling type_class() on a MixinAppType fails.
   Isolate* isolate = Isolate::Current();
   Class& cls = Class::Handle(isolate);
   AbstractType& sup_type = AbstractType::Handle(isolate);
   cls = raw();
   intptr_t num_type_args = 0;
   do {
     if (cls.IsSignatureClass()) {
       Function& signature_fun = Function::Handle(isolate);
       signature_fun ^= cls.signature_function();
       if (!signature_fun.is_static() &&
           !signature_fun.HasInstantiatedSignature()) {
         cls = signature_fun.Owner();
       }
     }
     // Calling NumOwnTypeArguments() on a mixin application class will setup the
     // type parameters if not already done.
     num_type_args += cls.NumOwnTypeArguments();
     // Super type of Object class is null.
     if ((cls.super_type() == AbstractType::null()) ||
         (cls.super_type() == isolate->object_store()->object_type())) {
       break;
     }
     sup_type = cls.super_type();
     cls = sup_type.type_class();
   } while (true);
+  set_num_type_arguments(num_type_args);
   return num_type_args;
 }
 
 
-// More efficient than calling NumTypeArguments().
-bool Class::HasTypeArguments() const {
-  // Fast check for a non-signature finalized class.
-  if (!IsSignatureClass() && (is_finalized() || is_prefinalized())) {
-    return type_arguments_field_offset() != kNoTypeArguments;
-  }
-  Isolate* isolate = Isolate::Current();
-  Class& cls = Class::Handle(isolate);
-  cls = raw();
-  do {
-    if (cls.IsSignatureClass()) {
-      Function& signature_fun = Function::Handle(isolate);
-      signature_fun ^= cls.signature_function();
-      if (!signature_fun.is_static() &&
-          !signature_fun.HasInstantiatedSignature()) {
-        cls = signature_fun.Owner();
-      }
-    }
-    if (cls.NumTypeParameters() > 0) {
-      return true;
-    }
-    if ((cls.super_type() == AbstractType::null()) ||
-        (cls.super_type() == isolate->object_store()->object_type())) {
-      return false;
-    }
-    cls = cls.SuperClass();
-    if (!cls.IsSignatureClass() &&
-        (cls.is_finalized() || cls.is_prefinalized())) {
-      return cls.type_arguments_field_offset() != kNoTypeArguments;
-    }
-  } while (true);
-  UNREACHABLE();
-}
-
-
 RawClass* Class::SuperClass() const {
   if (super_type() == AbstractType::null()) {
     return Class::null();
   }
   const AbstractType& sup_type = AbstractType::Handle(super_type());
   return sup_type.type_class();
 }
 
 
 void Class::set_super_type(const AbstractType& value) const {
@@ skipping 187 matching lines @@
   // Prefinalized classes have a VM internal representation and no Dart fields.
   // Their instance size  is precomputed and field offsets are known.
   if (!is_prefinalized()) {
     // Compute offsets of instance fields and instance size.
     CalculateFieldOffsets();
   }
   set_is_finalized();
 }
 
 
-static RawError* FormatError(const Error& prev_error,
-                             const Script& script,
-                             intptr_t token_pos,
-                             const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  if (prev_error.IsNull()) {
-    return Parser::FormatError(script, token_pos, "Error", format, args);
-  } else {
-    return Parser::FormatErrorWithAppend(prev_error, script, token_pos,
-                                         "Error", format, args);
-  }
-}
-
-
 // Apply the members from the patch class to the original class.
 bool Class::ApplyPatch(const Class& patch, Error* error) const {
   ASSERT(error != NULL);
   ASSERT(!is_finalized());
   // Shared handles used during the iteration.
   String& member_name = String::Handle();
 
   const PatchClass& patch_class =
       PatchClass::Handle(PatchClass::New(*this, patch));
 
@@ skipping 185 matching lines @@
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::InstanceSize());
   result.set_id(index);
-  result.raw_ptr()->state_bits_ = 0;
-  result.raw_ptr()->type_arguments_field_offset_in_words_ = kNoTypeArguments;
-  result.raw_ptr()->num_native_fields_ = 0;
-  result.raw_ptr()->token_pos_ = Scanner::kDummyTokenIndex;
+  result.set_state_bits(0);
+  result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
+  result.set_num_type_arguments(kUnknownNumTypeArguments);
+  result.set_num_own_type_arguments(kUnknownNumTypeArguments);
+  result.set_num_native_fields(0);
+  result.set_token_pos(Scanner::kDummyTokenIndex);
   result.InitEmptyFields();
   Isolate::Current()->RegisterClass(result);
   return result.raw();
 }
 
 
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
   Class& result = Class::Handle(New<Instance>(kIllegalCid));
@@ skipping 328 matching lines @@
     return (test_kind == kIsMoreSpecificThan) ||
         other.IsObjectClass() || other.IsNullClass();
   }
   // Check for ObjectType. Any type that is not NullType or DynamicType (already
   // checked above), is more specific than ObjectType.
   if (other.IsObjectClass()) {
     return true;
   }
   // Check for reflexivity.
   if (raw() == other.raw()) {
-    if (!HasTypeArguments()) {
+    const intptr_t len = NumTypeArguments();
+    if (len == 0) {
       return true;
     }
-    const intptr_t len = NumTypeArguments();
     // Since we do not truncate the type argument vector of a subclass (see
     // below), we only check a prefix of the proper length.
     // Check for covariance.
     if (other_type_arguments.IsNull() || other_type_arguments.IsRaw(len)) {
       return true;
     }
     if (type_arguments.IsNull() || type_arguments.IsRaw(len)) {
       // Other type can't be more specific than this one because for that
       // it would have to have all dynamic type arguments which is checked
       // above.
@@ skipping 8050 matching lines @@
   return result.raw();
 }
 
 
 RawType* Instance::GetType() const {
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
-  if (cls.HasTypeArguments()) {
+  if (cls.NumTypeArguments() > 0) {
     type_arguments = GetTypeArguments();
   }
   const Type& type = Type::Handle(
       Type::New(cls, type_arguments, Scanner::kDummyTokenIndex));
   type.SetIsFinalized();
   return type.raw();
 }
 
 
 RawAbstractTypeArguments* Instance::GetTypeArguments() const {
@@ skipping 21 matching lines @@
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsMalformed());
   ASSERT(!other.IsMalbounded());
   if (other.IsVoidType()) {
     return false;
   }
   Isolate* isolate = Isolate::Current();
   const Class& cls = Class::Handle(isolate, clazz());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(isolate);
-  if (cls.HasTypeArguments()) {
+  if (cls.NumTypeArguments() > 0) {
     type_arguments = GetTypeArguments();
     if (!type_arguments.IsNull() && !type_arguments.IsCanonical()) {
       type_arguments = type_arguments.Canonicalize();
       SetTypeArguments(type_arguments);
     }
     // 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
@@ skipping 588 matching lines @@
   return Isolate::Current()->object_store()->array_type();
 }
 
 
 RawType* Type::Function() {
   return Isolate::Current()->object_store()->function_type();
 }
 
 
 RawType* Type::NewNonParameterizedType(const Class& type_class) {
-  ASSERT(!type_class.HasTypeArguments());
+  ASSERT(type_class.NumTypeArguments() == 0);
   const TypeArguments& no_type_arguments = TypeArguments::Handle();
   Type& type = Type::Handle();
   type ^= Type::New(Object::Handle(type_class.raw()),
                     no_type_arguments,
                     Scanner::kDummyTokenIndex);
   type.SetIsFinalized();
   type ^= type.Canonicalize();
   return type.raw();
 }
 
@@ skipping 4101 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart