Replace calls to Class::IsParameterized() by either

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 820 matching lines @@
   const Array& type_params = Array::Handle(type_parameters());
   if (type_params.IsNull()) {
     return 0;
   } else {
     return type_params.Length();
   }
 }
 
 
 intptr_t Class::NumTypeArguments() const {
+  // To work properly, this call requires the super class of this class to be
+  // resolved, which is checked by the SuperClass() call.
   intptr_t num_type_args = NumTypeParameters();
   const Class& superclass = Class::Handle(SuperClass());
   // Object is its own super class during bootstrap.
   if (!superclass.IsNull() && (superclass.raw() != raw())) {
     num_type_args += superclass.NumTypeArguments();
   }
   return num_type_args;
 }
 
 
@@ skipping 163 matching lines @@
                                    const Function& signature_function,
                                    const Script& script,
                                    intptr_t token_index) {
   ASSERT(!signature_function.IsNull());
   Type& super_type = Type::Handle(Type::ObjectType());
   const Class& owner_class = Class::Handle(signature_function.owner());
   ASSERT(!owner_class.IsNull());
   Array& type_parameters = Array::Handle();
   TypeArray& type_parameter_extends = TypeArray::Handle();
   if (!signature_function.is_static()) {
-    if (owner_class.IsParameterized() &&
+    if ((owner_class.NumTypeParameters() > 0) &&
         !signature_function.HasInstantiatedSignature()) {
       // Share the function owner super class as the super class of the
       // signature class, so that the type argument vector of the closure at
       // run time  matches the type argument vector of the closure instantiator.
       type_parameters = owner_class.type_parameters();
       type_parameter_extends = owner_class.type_parameter_extends();
       if (!owner_class.is_interface()) {
         super_type = owner_class.super_type();
       }
     }
@@ skipping 172 matching lines @@
     const TypeArguments& other_type_arguments) const {
   // Check for VarType.
   // The VarType on the lefthand side is replaced by the bottom type, which is
   // more specific than any type.
   // Any type is more specific than the VarType on the righthand side.
   if (IsVarClass() || other.IsVarClass()) {
     return true;
   }
   // Check for reflexivity.
   if (raw() == other.raw()) {
-    if (!IsParameterized()) {
+    const intptr_t len = NumTypeArguments();
+    if (len == 0) {
       return true;
     }
     // Since we do not truncate the type argument vector of a subclass (see
     // below), we only check a prefix of the proper length.
-    const intptr_t len = NumTypeArguments();
     // Check for covariance.
     if (type_arguments.IsNull() ||
         other_type_arguments.IsNull() ||
         type_arguments.IsVarTypes(len) ||
         other_type_arguments.IsVarTypes(len)) {
       return true;
     }
     return type_arguments.IsMoreSpecificThan(other_type_arguments, len);
   }
   // Check for 'direct super type' in the case of an interface and check for
@@ skipping 96 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(IsParameterized());  // Otherwise IsMoreSpecificThan would be true.
+  ASSERT(NumTypeArguments() > 0);  // Or 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 3121 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.IsParameterized()) {
+  if (cls.NumTypeArguments() > 0) {
     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 27 matching lines @@
         return true;
       }
       return false;
     } else {
       ASSERT(test == Type::kIsAssignableTo);
       return true;
     }
   }
   const Class& cls = Class::Handle(clazz());
   TypeArguments& type_arguments = TypeArguments::Handle();
-  if (cls.IsParameterized()) {
+  const intptr_t num_type_arguments = cls.NumTypeArguments();
+  if (num_type_arguments > 0) {
     type_arguments = GetTypeArguments();
     // Verify that the number of type arguments in the instance matches 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 super class of the class
     // defining the closure. Truncating the vector to the correct length on
     // instantiation is unnecessary. The vector may therefore be longer.
     ASSERT(type_arguments.IsNull() ||
-           (type_arguments.Length() == cls.NumTypeArguments()) ||
+           (type_arguments.Length() == num_type_arguments) ||
            (cls.IsSignatureClass() &&
-            (type_arguments.Length() > cls.NumTypeArguments())));
+            (type_arguments.Length() > num_type_arguments)));
   }
   Class& other_class = Class::Handle();
   TypeArguments& other_type_arguments = TypeArguments::Handle();
   // In case 'other' is not instantiated, we could simply call
   // other.InstantiateFrom(other_instantiator, 0), however, we can save the
   // allocation of a new Type by inlining the code.
   if (other.IsTypeParameter()) {
     Type& instantiated_other = Type::Handle();
     if (!other_instantiator.IsNull()) {
       instantiated_other = other_instantiator.TypeAt(other.Index());
@@ skipping 1904 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