[VM generic function reification] Support generic functions in Invocation class.

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/become.h"
@@ skipping 895 matching lines @@
 
   cls = dynamic_class_;
   *dynamic_type_ = Type::NewNonParameterizedType(cls);
 
   cls = void_class_;
   *void_type_ = Type::NewNonParameterizedType(cls);
 
   cls = vector_class_;
   *vector_type_ = Type::NewNonParameterizedType(cls);
 
+  // Since TypeArguments objects are passed as function arguments, make them
+  // behave as Dart instances, although they are just VM objects.
+  // Note that we cannot set the super type to ObjectType, which does not live
+  // in the vm isolate. See special handling in Class::SuperClass().
+  cls = type_arguments_class_;
+  cls.set_interfaces(Object::empty_array());
+  cls.SetFields(Object::empty_array());
+  cls.SetFunctions(Object::empty_array());
+
   // Allocate and initialize singleton true and false boolean objects.
   cls = Class::New<Bool>();
   isolate->object_store()->set_bool_class(cls);
   *bool_true_ = Bool::New(true);
   *bool_false_ = Bool::New(false);
 
   *smi_illegal_cid_ = Smi::New(kIllegalCid);
 
   String& error_str = String::Handle();
   error_str = String::New("SnapshotWriter Error", Heap::kOld);
@@ skipping 1149 matching lines @@
     NoSafepointScope no_safepoint;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::NextFieldOffset());
   COMPILE_ASSERT((FakeObject::kClassId != kInstanceCid));
   result.set_id(FakeObject::kClassId);
   result.set_state_bits(0);
-  if (FakeObject::kClassId < kInstanceCid) {
+  if ((FakeObject::kClassId < kInstanceCid) ||
+      (FakeObject::kClassId == kTypeArgumentsCid)) {
     // VM internal classes are done. There is no finalization needed or
     // possible in this case.
     result.set_is_finalized();
   } else {
     // VM backed classes are almost ready: run checks and resolve class
     // references, but do not recompute size.
     result.set_is_prefinalized();
   }
   result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
   result.set_num_type_arguments(0);
@@ skipping 411 matching lines @@
   } while (true);
   set_num_type_arguments(num_type_args);
   return num_type_args;
 }
 
 RawClass* Class::SuperClass(bool original_classes) const {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   if (super_type() == AbstractType::null()) {
+    if (id() == kTypeArgumentsCid) {
+      // Pretend TypeArguments objects are Dart instances.
+      return isolate->class_table()->At(kInstanceCid);
+    }
     return Class::null();
   }
   const AbstractType& sup_type = AbstractType::Handle(zone, super_type());
   const intptr_t type_class_id = sup_type.type_class_id();
   if (original_classes) {
     return isolate->GetClassForHeapWalkAt(type_class_id);
   } else {
     return isolate->class_table()->At(type_class_id);
   }
 }
@@ skipping 19943 matching lines @@
   }
   return UserTag::null();
 }
 
 const char* UserTag::ToCString() const {
   const String& tag_label = String::Handle(label());
   return tag_label.ToCString();
 }
 
 }  // namespace dart