Address review comments of previously submitted cl 8329005.

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 338 matching lines @@
   // has been created.
   cls.InitEmptyFields();
 
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
   cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset());
 
   // Allocate and initialize the object class and type.
   cls = Class::New<Instance>();
   object_store->set_object_class(cls);
-  // The bootstrap script is not compiled yet, so the superclass of Object does
-  // not yet point to itself, therefore, Type::NewNonParameterizedType(cls)
-  // can safely assert that cls.NumTypeArguments() == 0 without entering an
-  // endless loop.
-  ASSERT(cls.SuperClass() == Class::null());
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
 
   cls = Class::New<Mint>();
   object_store->set_mint_class(cls);
 
   cls = Class::New<Bigint>();
@@ skipping 957 matching lines @@
   }
   // TODO(regis): Merge IsMoreSpecificThan here after type checks for
   // function types are finalized and implemented.
   // For now, keep the assert below.
 
   // The optionality and dubious bliss rules described in the guide have
   // already been checked in IsMoreSpecificThan call above.
   if (raw() != other.raw()) {
     return false;
   }
-  ASSERT(NumTypeArguments() > 0);  // Or IsMoreSpecificThan would be true.
+  ASSERT(HasTypeArguments());  // Otherwise, IsMoreSpecificThan would be true.
   return false;
 }
 
 
 RawFunction* Class::LookupDynamicFunction(const String& name) const {
   Function& function = Function::Handle(LookupFunction(name));
   if (function.IsNull() || function.is_static()) {
     return Function::null();
   }
   switch (function.kind()) {
@@ skipping 507 matching lines @@
 
 
 RawType* Type::NewRawType(const Class& type_class) {
   const TypeArguments& type_arguments =
       TypeArguments::Handle(type_class.type_parameter_extends());
   return NewParameterizedType(Object::Handle(type_class.raw()), type_arguments);
 }
 
 
 RawType* Type::NewNonParameterizedType(const Class& type_class) {
-  ASSERT(type_class.NumTypeArguments() == 0);
+  ASSERT(!type_class.HasTypeArguments());
   const TypeArguments& no_type_arguments = TypeArguments::Handle();
   ParameterizedType& type = ParameterizedType::Handle();
   type ^= ParameterizedType::New(
       Object::Handle(type_class.raw()), no_type_arguments);
   type.set_is_finalized();
   return type.raw();
 }
 
 
 RawType* Type::NewParameterizedType(const Object& clazz,
@@ skipping 2599 matching lines @@
   return this->raw();
 }
 
 
 RawType* Instance::GetType() const {
   if (IsNull()) {
     return Type::NullType();
   }
   const Class& cls = Class::Handle(clazz());
   TypeArguments& type_arguments = TypeArguments::Handle();
-  if (cls.NumTypeArguments() > 0) {
+  if (cls.HasTypeArguments()) {
     type_arguments = GetTypeArguments();
   }
   return Type::NewParameterizedType(cls, type_arguments);
 }
 
 
 RawTypeArguments* Instance::GetTypeArguments() const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_instance_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
@@ skipping 1964 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart