Simplyfy the NumTypeArguments check.

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 958 matching lines @@
   cls.set_is_prefinalized();
   pending_classes.Add(cls, Heap::kOld);
   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);
 
   // Note: The abstract class Function is represented by VM class
   // DartFunction, not VM class Function.
   cls = Class::New<DartFunction>();
   RegisterClass(cls, Symbols::Function(), core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_type(type);
 
@@ skipping 590 matching lines @@
     return 0;
   }
   const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   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.
-  Class& cls = Class::Handle(raw());
+  Isolate* isolate = Isolate::Current();
+  Class& cls = Class::Handle(isolate, raw());
   intptr_t num_type_args = 0;
 
   do {
     if (cls.IsSignatureClass()) {
       const Function& signature_fun =
-          Function::Handle(cls.signature_function());
+          Function::Handle(isolate, cls.signature_function());
       if (!signature_fun.is_static() &&
           !signature_fun.HasInstantiatedSignature()) {
         cls = signature_fun.Owner();
       }
     }
     num_type_args += cls.NumTypeParameters();
     // Object is its own super class during bootstrap.

[Ivan Posva, 2013/06/01 01:10:34]

Why does Object have to be its own super class during bootstrap? The check would
be even simpler if we did not have that mode change.

[siva, 2013/06/03 17:43:38]

Not sure, I will have to wait for Regis to answer this question.
I looked at Object::Init and don't see super_type being set to
its own super class.


On 2013/06/01 01:10:34, Ivan Posva wrote:

[regis, 2013/06/10 15:19:35]

I do not think we have to set the super_type of class Object to type Object. The
parser does it when parsing "class Object", because no extend clause is
specified.

On 2013/06/03 17:43:38, siva wrote:

[siva, 2013/06/11 00:34:02]

If I remove the setting in parser.cc during parsing we get a failure during
class finalization:
#0  0xf7fdb430 in __kernel_vsyscall ()
#1  0xf7ce61df in raise () from /lib/i386-linux-gnu/libc.so.6
#2  0xf7ce9825 in abort () from /lib/i386-linux-gnu/libc.so.6
#3  0x080822fa in dart::DynamicAssertionHelper::Fail (this=0xffffbe24, 
    format=0x83fc515 "%s") at runtime/platform/assert.cc:40
#4  0x081e1a26 in dart::AbstractType::IsResolved (this=0x86c1620)
    at runtime/vm/object.cc:9325
#5  0x08090a37 in dart::ClassFinalizer::ResolveType (cls=..., type=..., 
    finalization=dart::ClassFinalizer::kCanonicalizeWellFormed)
    at runtime/vm/class_finalizer.cc:419
#6  0x08098579 in dart::ClassFinalizer::ResolveSuperTypeAndInterfaces (cls=..., 
    visited=0xffffc0b0) at runtime/vm/class_finalizer.cc:1711
#7  0x08099365 in dart::ClassFinalizer::FinalizePendingClasses ()
    at runtime/vm/class_finalizer.cc:147





On 2013/06/10 15:19:35, regis wrote:

[regis, 2013/06/11 11:51:14]

Sorry, I was not clear.

Classes that do not specify an extend clause must have their super type set to
Object type. We cannot remove the setting code from parser.cc.

Now, class Object is a special case, because it has no super type. Leaving the
default Object type as its super type would create a cycle. This is why
object.cc removes the cycle after class Object has been parsed.

There is no need to change anything in parser.cc or object.cc.
But if you think it is cleaner, we can move the special handling from object.cc
to parser.cc. I'll send a cl and you can decide if you like it better.


On 2013/06/11 00:34:02, siva wrote:

-    if (cls.SuperClass() == Class::null() || cls.SuperClass() == cls.raw()) {
+    if (cls.super_type() == Type::null() ||
+        cls.super_type() == isolate->object_store()->object_type()) {
       break;
     }
     cls = cls.SuperClass();
   } while (true);
   return num_type_args;
 }
 
 
 bool Class::HasTypeArguments() const {
   if (!IsSignatureClass() && (is_type_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);
   }
 }
 
 
 RawClass* Class::SuperClass() const {
-  const AbstractType& sup_type = AbstractType::Handle(super_type());
-  if (sup_type.IsNull()) {
+  if (super_type() == Type::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 {
   ASSERT(value.IsNull() ||
          value.IsType() ||
          value.IsBoundedType() ||
          value.IsMixinAppType());
   StorePointer(&raw_ptr()->super_type_, value.raw());
@@ skipping 5245 matching lines @@
     // There is a list of visible names. The name we're looking for is not
     // contained in the list, so it is hidden.
     return true;
   }
   // The name is not filtered out.
   return false;
 }
 
 
 RawObject* Namespace::Lookup(const String& name) const {
-  const Library& lib = Library::Handle(library());
+  Isolate* isolate = Isolate::Current();
+  const Library& lib = Library::Handle(isolate, library());
   intptr_t ignore = 0;
   // Lookup the name in the library's symbols.
-  Object& obj = Object::Handle(lib.LookupEntry(name, &ignore));
+  Object& obj = Object::Handle(isolate, lib.LookupEntry(name, &ignore));
   if (obj.IsNull()) {
     // Lookup in the re-exported symbols.
     obj = lib.LookupExport(name);
   }
   if (obj.IsNull() || HidesName(name)) {
     return Object::null();
   }
   return obj.raw();
 }
 
@@ skipping 6394 matching lines @@
                                     space);
   return reinterpret_cast<RawWeakProperty*>(raw);
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart