- Get rid of RawClosure class and use RawInstance for closures.

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/bigint_operations.h"
@@ skipping 1327 matching lines @@
     RawObject* raw = Object::Allocate(Class::kClassId,
                                       Class::InstanceSize(),
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::InstanceSize());
-  ASSERT((FakeObject::kClassId != kInstanceCid) &&
-         (FakeObject::kClassId != kClosureCid));
+  ASSERT((FakeObject::kClassId != kInstanceCid));
   result.set_id(FakeObject::kClassId);
   result.raw_ptr()->state_bits_ = 0;
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
   result.set_is_prefinalized();
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
   result.raw_ptr()->num_native_fields_ = 0;
   result.raw_ptr()->token_pos_ = Scanner::kDummyTokenIndex;
   result.InitEmptyFields();
   Isolate::Current()->class_table()->Register(result);
@@ skipping 411 matching lines @@
   result.raw_ptr()->state_bits_ = 0;
   result.raw_ptr()->type_arguments_instance_field_offset_ = kNoTypeArguments;
   result.raw_ptr()->num_native_fields_ = 0;
   result.raw_ptr()->token_pos_ = Scanner::kDummyTokenIndex;
   result.InitEmptyFields();
   Isolate::Current()->class_table()->Register(result);
   return result.raw();
 }
 
 
-// Force instantiation of template version to work around ld problems.
-template RawClass* Class::New<Closure>(intptr_t index);
-
-
 template <class FakeInstance>
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
   Class& result = Class::Handle(New<FakeInstance>(kIllegalCid));
   result.set_name(name);
   result.set_script(script);
   result.set_token_pos(token_pos);
   return result.raw();
 }
@@ skipping 25 matching lines @@
   TypeArguments& type_parameters = TypeArguments::Handle();
   // A signature class extends class Instance and is parameterized in the same
   // way as the owner class of its non-static signature function.
   // It is not type parameterized if its signature function is static.
   if (!signature_function.is_static() &&
       (owner_class.NumTypeParameters() > 0) &&
       !signature_function.HasInstantiatedSignature()) {
     type_parameters = owner_class.type_parameters();
   }
   const intptr_t token_pos = signature_function.token_pos();
-  Class& result = Class::Handle(New<Closure>(name, script, token_pos));
+  Class& result = Class::Handle(New<Instance>(name, script, token_pos));
   const Type& super_type = Type::Handle(Type::ObjectType());
   const Array& empty_array = Array::Handle(Object::empty_array());
   ASSERT(!super_type.IsNull());
+  result.set_instance_size(Closure::InstanceSize());
+  result.set_next_field_offset(Closure::InstanceSize());
   result.set_super_type(super_type);
   result.set_signature_function(signature_function);
   result.set_type_parameters(type_parameters);
   result.SetFields(empty_array);
   result.SetFunctions(empty_array);
   result.set_type_arguments_instance_field_offset(
       Closure::type_arguments_offset());
   // Implements interface "Function".
   const Type& function_type = Type::Handle(Type::Function());
   const Array& interfaces = Array::Handle(Array::New(1, Heap::kOld));
@@ skipping 1291 matching lines @@
     return;
   }
   UNREACHABLE();
 }
 
 
 bool Function::IsRedirectingFactory() const {
   if (!IsFactory() || (raw_ptr()->data_ == Object::null())) {
     return false;
   }
-  ASSERT(!IsClosure());  // A factory cannot also be a closure.
+  ASSERT(!IsClosureFunction());  // A factory cannot also be a closure.
   return true;
 }
 
 
 RawType* Function::RedirectionType() const {
   ASSERT(IsRedirectingFactory());
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(!obj.IsNull());
   return RedirectionData::Cast(obj).type();
 }
@@ skipping 4950 matching lines @@
         !other_type_arguments.IsInstantiated()) {
       other_type_arguments =
           other_type_arguments.InstantiateFrom(other_instantiator);
     }
   }
   return cls.IsSubtypeOf(type_arguments, other_class, other_type_arguments,
                          malformed_error);
 }
 
 
+bool Instance::IsClosure() const {
+  const Class& cls = Class::Handle(clazz());
+  return cls.IsSignatureClass();
+}
+
+
 RawInstance* Instance::New(const Class& cls, Heap::Space space) {
   Instance& result = Instance::Handle();
   {
     intptr_t instance_size = cls.instance_size();
     ASSERT(instance_size > 0);
     RawObject* raw = Object::Allocate(cls.id(), instance_size, space);
     NoGCScope no_gc;
     result ^= raw;
     uword addr = reinterpret_cast<uword>(result.raw_ptr());
     // Initialize fields.
@@ skipping 18 matching lines @@
   if (IsNull()) {
     return "null";
   } else if (raw() == Object::sentinel()) {
     return "sentinel";
   } else if (raw() == Object::transition_sentinel()) {
     return "transition_sentinel";
   } else if (Isolate::Current()->no_gc_scope_depth() > 0) {
     // Can occur when running disassembler.
     return "Instance";
   } else {
+    if (IsClosure()) {
+      const Function& fun = Function::Handle(Closure::function(*this));

[Ivan Posva, 2012/10/11 04:04:22]

Could this be abstracted out into a function in the Closure class?

[siva, 2012/10/11 17:45:58]

Done.

+      const bool is_implicit_closure = fun.IsImplicitClosureFunction();
+      const char* fun_sig = String::Handle(fun.Signature()).ToCString();
+      const char* from = is_implicit_closure ? " from " : "";
+      const char* fun_desc = is_implicit_closure ? fun.ToCString() : "";
+      const char* format = "Closure: %s%s%s";
+      intptr_t len = OS::SNPrint(NULL, 0, format, fun_sig, from, fun_desc) + 1;
+      char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+      OS::SNPrint(chars, len, format, fun_sig, from, fun_desc);
+      return chars;
+    }
     const char* kFormat = "Instance of '%s'";
-    Class& cls = Class::Handle(clazz());
+    const Class& cls = Class::Handle(clazz());
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
     const Type& type =
         Type::Handle(Type::New(cls, type_arguments, Scanner::kDummyTokenIndex));
     const String& type_name = String::Handle(type.Name());
     // Calculate the size of the string.
     intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
@@ skipping 3715 matching lines @@
       cls, data, len, peer, callback, space);
 }
 
 
 const char* ExternalFloat64Array::ToCString() const {
   return "_ExternalFloat64Array";
 }
 
 
 
-RawClosure* Closure::New(const Function& function,
-                         const Context& context,
-                         Heap::Space space) {
+RawInstance* Closure::New(const Function& function,
+                          const Context& context,
+                          Heap::Space space) {
   Isolate* isolate = Isolate::Current();
   ASSERT(context.isolate() == isolate);
 
   const Class& cls = Class::Handle(function.signature_class());
-  Closure& result = Closure::Handle();
+  ASSERT(cls.instance_size() == Closure::InstanceSize());
+  Instance& result = Instance::Handle();
   {
     RawObject* raw = Object::Allocate(cls.id(), Closure::InstanceSize(), space);
     NoGCScope no_gc;
     result ^= raw;
   }
-  result.set_function(function);
-  result.set_context(context);
+  Closure::set_function(result, function);
+  Closure::set_context(result, context);
   return result.raw();
 }
 
 
-void Closure::set_context(const Context& value) const {
-  StorePointer(&raw_ptr()->context_, value.raw());
-}
-
-
-void Closure::set_function(const Function& value) const {
-  StorePointer(&raw_ptr()->function_, value.raw());
-}
-
-
 const char* DartFunction::ToCString() const {
   return "Function type class";
 }
 
 
-const char* Closure::ToCString() const {
-  const Function& fun = Function::Handle(function());
-  const bool is_implicit_closure = fun.IsImplicitClosureFunction();
-  const char* fun_sig = String::Handle(fun.Signature()).ToCString();
-  const char* from = is_implicit_closure ? " from " : "";
-  const char* fun_desc = is_implicit_closure ? fun.ToCString() : "";
-  const char* format = "Closure: %s%s%s";
-  intptr_t len = OS::SNPrint(NULL, 0, format, fun_sig, from, fun_desc) + 1;
-  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
-  OS::SNPrint(chars, len, format, fun_sig, from, fun_desc);
-  return chars;
-}
-
-
 intptr_t Stacktrace::Length() const {
   const Array& code_array = Array::Handle(raw_ptr()->code_array_);
   return code_array.Length();
 }
 
 
 RawFunction* Stacktrace::FunctionAtFrame(intptr_t frame_index) const {
   const Array& function_array = Array::Handle(raw_ptr()->function_array_);
   return reinterpret_cast<RawFunction*>(function_array.At(frame_index));
 }
@@ skipping 249 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart