Simplyfy the NumTypeArguments check.

runtime/vm/object.cc

Index: runtime/vm/object.cc
===================================================================
--- runtime/vm/object.cc	(revision 23504)
+++ runtime/vm/object.cc	(working copy)
@@ -976,6 +976,7 @@
   // 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
@@ -1586,13 +1587,14 @@
 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();
@@ -1600,7 +1602,8 @@
     }
     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();
@@ -1621,10 +1624,10 @@
 
 
 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();
 }
 
@@ -6890,10 +6893,11 @@
 
 
 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);