Rewrite Class::HasTypeArguments() for efficiency.

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 1694 matching lines @@
 
 
 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 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);
   TypeArguments& type_params = TypeArguments::Handle(isolate);
   AbstractType& sup_type = AbstractType::Handle(isolate);
-  cls ^= raw();
+  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 NumTypeParameters() on a mixin application class will setup the
     // type parameters if not already done.
     if (cls.NumTypeParameters() > 0) {
       type_params ^= cls.type_parameters();
       num_type_args += type_params.Length();
     }
     // 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();
+    sup_type = cls.super_type();
     cls = sup_type.type_class();
   } while (true);
   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())) {
-    // More efficient than calling NumTypeArguments().
     return type_arguments_field_offset() != kNoTypeArguments;
-  } else {
-    // No need to check NumTypeArguments() if class has type parameters.
-    return (NumTypeParameters() > 0) || (NumTypeArguments() > 0);
   }
+  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();
 }
@@ skipping 13553 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart