Use HasTypeArguments instead of first computing NumTypeArguments();

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 2538 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()) {
-    const intptr_t len = NumTypeArguments();
-    if (len == 0) {
+    if (!HasTypeArguments()) {
       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 8030 matching lines @@
 bool Instance::IsInstanceOf(const AbstractType& other,
                             const AbstractTypeArguments& other_instantiator,
                             Error* bound_error) const {
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsMalformed());
   ASSERT(!other.IsMalbounded());
   if (other.IsVoidType()) {
     return false;
   }
-  const Class& cls = Class::Handle(clazz());
-  AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
-  const intptr_t num_type_arguments = cls.NumTypeArguments();
-  if (num_type_arguments > 0) {
+  Isolate* isolate = Isolate::Current();
+  const Class& cls = Class::Handle(isolate, clazz());
+  AbstractTypeArguments& type_arguments =
+      AbstractTypeArguments::Handle(isolate);
+  if (cls.HasTypeArguments()) {
     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
     // instantiation is unnecessary. The vector may therefore be longer.
     // Also, an optimization reuses the type argument vector of the instantiator
     // of generic instances when its layout is compatible.
     ASSERT(type_arguments.IsNull() ||
-           (type_arguments.Length() >= num_type_arguments));
+           (type_arguments.Length() >= cls.NumTypeArguments()));
   }
-  Class& other_class = Class::Handle();
-  AbstractTypeArguments& other_type_arguments = AbstractTypeArguments::Handle();
+  Class& other_class = Class::Handle(isolate);
+  AbstractTypeArguments& other_type_arguments =
+      AbstractTypeArguments::Handle(isolate);
   // Note that we may encounter a bound error in checked mode.
   if (!other.IsInstantiated()) {
     const AbstractType& instantiated_other = AbstractType::Handle(
-        other.InstantiateFrom(other_instantiator, bound_error));
+        isolate, other.InstantiateFrom(other_instantiator, bound_error));
     if ((bound_error != NULL) && !bound_error->IsNull()) {
       ASSERT(FLAG_enable_type_checks);
       return false;
     }
     other_class = instantiated_other.type_class();
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
     other_type_arguments = other.arguments();
   }
@@ skipping 4691 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart