Move all the closure related fields in RawFunction into a new class

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 61 matching lines @@
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::unresolved_class_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_parameter_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_arguments_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::patch_class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::closure_data_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::field_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::literal_token_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::token_stream_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::script_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_prefix_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::code_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::pc_descriptors_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::stackmap_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 232 matching lines @@
 
   cls = Class::New<InstantiatedTypeArguments>();
   instantiated_type_arguments_class_ = cls.raw();
 
   cls = Class::New<PatchClass>();
   patch_class_class_ = cls.raw();
 
   cls = Class::New<Function>();
   function_class_ = cls.raw();
 
+  cls = Class::New<ClosureData>();
+  closure_data_class_ = cls.raw();
+
   cls = Class::New<Field>();
   field_class_ = cls.raw();
 
   cls = Class::New<LiteralToken>();
   literal_token_class_ = cls.raw();
 
   cls = Class::New<TokenStream>();
   token_stream_class_ = cls.raw();
 
   cls = Class::New<Script>();
@@ skipping 84 matching lines @@
   SET_CLASS_NAME(null, Null);
   SET_CLASS_NAME(dynamic, Dynamic);
   SET_CLASS_NAME(void, Void);
   SET_CLASS_NAME(unresolved_class, UnresolvedClass);
   SET_CLASS_NAME(type, Type);
   SET_CLASS_NAME(type_parameter, TypeParameter);
   SET_CLASS_NAME(type_arguments, TypeArguments);
   SET_CLASS_NAME(instantiated_type_arguments, InstantiatedTypeArguments);
   SET_CLASS_NAME(patch_class, PatchClass);
   SET_CLASS_NAME(function, Function);
+  SET_CLASS_NAME(closure_data, ClosureData);
   SET_CLASS_NAME(field, Field);
   SET_CLASS_NAME(literal_token, LiteralToken);
   SET_CLASS_NAME(token_stream, TokenStream);
   SET_CLASS_NAME(script, Script);
   SET_CLASS_NAME(library, LibraryClass);
   SET_CLASS_NAME(library_prefix, LibraryPrefix);
   SET_CLASS_NAME(code, Code);
   SET_CLASS_NAME(instructions, Instructions);
   SET_CLASS_NAME(pc_descriptors, PcDescriptors);
   SET_CLASS_NAME(stackmap, Stackmap);
@@ skipping 3346 matching lines @@
   SetCode(Code::Handle(unoptimized_code()));
   CodePatcher::RestoreEntry(Code::Handle(unoptimized_code()));
 }
 
 
 void Function::set_unoptimized_code(const Code& value) const {
   StorePointer(&raw_ptr()->unoptimized_code_, value.raw());
 }
 
 
+RawContextScope* Function::context_scope() const {
+  if (IsClosureFunction()) {
+    const Object& obj = Object::Handle(raw_ptr()->data_);
+    ASSERT(!obj.IsNull());
+    return ClosureData::Cast(obj).context_scope();
+  }
+  return ContextScope::null();
+}
+
+
 void Function::set_context_scope(const ContextScope& value) const {
-  StorePointer(&raw_ptr()->context_scope_, value.raw());
+  if (IsClosureFunction()) {
+    const Object& obj = Object::Handle(raw_ptr()->data_);
+    ASSERT(!obj.IsNull());
+    ClosureData::Cast(obj).set_context_scope(value);
+    return;
+  }
+  UNREACHABLE();
+}
+
+
+RawCode* Function::closure_allocation_stub() const {
+  if (IsClosureFunction()) {
+    const Object& obj = Object::Handle(raw_ptr()->data_);
+    ASSERT(!obj.IsNull());
+    return ClosureData::Cast(obj).closure_allocation_stub();
+  }
+  return Code::null();
 }
 
 
 void Function::set_closure_allocation_stub(const Code& value) const {
-  ASSERT(!value.IsNull());
-  ASSERT(raw_ptr()->closure_allocation_stub_ == Code::null());
-  StorePointer(&raw_ptr()->closure_allocation_stub_, value.raw());
+  if (IsClosureFunction()) {
+    const Object& obj = Object::Handle(raw_ptr()->data_);
+    ASSERT(!obj.IsNull());
+    ClosureData::Cast(obj).set_closure_allocation_stub(value);
+    return;
+  }
+  UNREACHABLE();
+}
+
+
+RawFunction* Function::parent_function() const {
+  if (IsClosureFunction()) {
+    const Object& obj = Object::Handle(raw_ptr()->data_);
+    ASSERT(!obj.IsNull());
+    return ClosureData::Cast(obj).parent_function();
+  }
+  return Function::null();
+}
+
+
+void Function::set_parent_function(const Function& value) const {
+  if (IsClosureFunction()) {
+    const Object& obj = Object::Handle(raw_ptr()->data_);
+    ASSERT(!obj.IsNull());
+    ClosureData::Cast(obj).set_parent_function(value);
+    return;
+  }
+  UNREACHABLE();
+}
+
+
+RawFunction* Function::implicit_closure_function() const {
+  if (IsClosureFunction() || IsSignatureFunction()) {
+    return Function::null();
+  }
+  const Object& obj = Object::Handle(raw_ptr()->data_);
+  ASSERT(obj.IsNull() || obj.IsFunction());
+  return (obj.IsNull()) ? Function::null() : Function::Cast(obj).raw();
 }
 
 
 void Function::set_implicit_closure_function(const Function& value) const {
-  ASSERT(!value.IsNull());
-  ASSERT(raw_ptr()->implicit_closure_function_ == Function::null());
-  StorePointer(&raw_ptr()->implicit_closure_function_, value.raw());
+  ASSERT(!IsClosureFunction() && !IsSignatureFunction());
+  set_data(value);
 }
 
 
-void Function::set_parent_function(const Function& value) const {
-  StorePointer(&raw_ptr()->parent_function_, value.raw());
+RawClass* Function::signature_class() const {
+  if (IsSignatureFunction()) {
+    const Object& obj = Object::Handle(raw_ptr()->data_);
+    ASSERT(obj.IsNull() || obj.IsClass());
+    return (obj.IsNull()) ? Class::null() : Class::Cast(obj).raw();
+  }
+  if (IsClosureFunction()) {
+    const Object& obj = Object::Handle(raw_ptr()->data_);
+    ASSERT(!obj.IsNull());
+    return ClosureData::Cast(obj).signature_class();
+  }
+  return Class::null();
 }
 
 
 void Function::set_signature_class(const Class& value) const {
-  StorePointer(&raw_ptr()->signature_class_, value.raw());
+  if (IsSignatureFunction()) {
+    set_data(value);
+    return;
+  }
+  if (IsClosureFunction()) {
+    const Object& obj = Object::Handle(raw_ptr()->data_);
+    ASSERT(!obj.IsNull());
+    ClosureData::Cast(obj).set_signature_class(value);
+    return;
+  }
+  UNREACHABLE();
+}
+
+
+void Function::set_data(const Object& value) const {
+  StorePointer(&raw_ptr()->data_, value.raw());
 }
 
 
 bool Function::IsInFactoryScope() const {
   Function& outer_function = Function::Handle(raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   return outer_function.IsFactory();
 }
@@ skipping 625 matching lines @@
   }
   return true;
 }
 
 
 bool Function::IsImplicitClosureFunction() const {
   if (!IsClosureFunction()) {
     return false;
   }
   const Function& parent = Function::Handle(parent_function());
-  return parent.raw_ptr()->implicit_closure_function_ == raw();
+  return (parent.implicit_closure_function() == raw());
 }
 
 
 RawFunction* Function::New() {
   ASSERT(Object::function_class() != Class::null());
   RawObject* raw = Object::Allocate(Function::kClassId,
                                     Function::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawFunction*>(raw);
 }
@@ skipping 23 matching lines @@
   result.set_token_pos(token_pos);
   result.set_end_token_pos(token_pos);
   result.set_num_fixed_parameters(0);
   result.set_num_optional_positional_parameters(0);
   result.set_num_optional_named_parameters(0);
   result.set_usage_counter(0);
   result.set_deoptimization_counter(0);
   result.set_is_optimizable(true);
   result.set_has_finally(false);
   result.set_is_native(false);
+  if (kind == RawFunction::kClosureFunction) {
+    const ClosureData& data = ClosureData::Handle(ClosureData::New());
+    result.set_data(data);
+  }
   return result.raw();
 }
 
 
 RawFunction* Function::NewClosureFunction(const String& name,
                                           const Function& parent,
                                           intptr_t token_pos) {
   ASSERT(name.IsOneByteString());
   ASSERT(!parent.IsNull());
   // Use the owner defining the parent function and not the class containing it.
   const Object& parent_owner = Object::Handle(parent.raw_ptr()->owner_);
   ASSERT(!parent_owner.IsNull());
   const Function& result = Function::Handle(
       Function::New(name,
                     RawFunction::kClosureFunction,
                     /* is_static = */ parent.is_static(),
                     /* is_const = */ false,
                     /* is_abstract = */ false,
                     /* is_external = */ false,
                     parent_owner,
                     token_pos));
   result.set_parent_function(parent);
   return result.raw();
 }
 
 
 RawFunction* Function::ImplicitClosureFunction() const {
   // Return the existing implicit closure function if any.
-  if (raw_ptr()->implicit_closure_function_ != Function::null()) {
-    return raw_ptr()->implicit_closure_function_;
+  if (implicit_closure_function() != Function::null()) {
+    return implicit_closure_function();
   }
   ASSERT(!IsSignatureFunction() && !IsClosureFunction());
   // Create closure function.
   const String& closure_name = String::Handle(name());
   const Function& closure_function = Function::Handle(
       NewClosureFunction(closure_name, *this, token_pos()));
 
   // Set closure function's context scope.
   ContextScope& context_scope = ContextScope::Handle();
   if (is_static()) {
@@ skipping 279 matching lines @@
   const char* function_name = String::Handle(name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name,
                              static_str, abstract_str, kind_str, const_str) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name,
               static_str, abstract_str, kind_str, const_str);
   return chars;
 }
 
 
+void ClosureData::set_context_scope(const ContextScope& value) const {
+  StorePointer(&raw_ptr()->context_scope_, value.raw());
+}
+
+
+void ClosureData::set_closure_allocation_stub(const Code& value) const {
+  ASSERT(!value.IsNull());
+  ASSERT(raw_ptr()->closure_allocation_stub_ == Code::null());
+  StorePointer(&raw_ptr()->closure_allocation_stub_, value.raw());
+}
+
+
+void ClosureData::set_parent_function(const Function& value) const {
+  StorePointer(&raw_ptr()->parent_function_, value.raw());
+}
+
+
+void ClosureData::set_signature_class(const Class& value) const {
+  StorePointer(&raw_ptr()->signature_class_, value.raw());
+}
+
+
+RawClosureData* ClosureData::New() {
+  ASSERT(Object::closure_data_class() != Class::null());
+  RawObject* raw = Object::Allocate(ClosureData::kClassId,
+                                    ClosureData::InstanceSize(),
+                                    Heap::kOld);
+  return reinterpret_cast<RawClosureData*>(raw);
+}
+
+
+const char* ClosureData::ToCString() const {
+  return "ClosureData class";
+}
+
+
 RawString* Field::GetterName(const String& field_name) {
   String& str = String::Handle();
   str = String::New(kGetterPrefix);
   str = String::Concat(str, field_name);
   return str.raw();
 }
 
 
 RawString* Field::GetterSymbol(const String& field_name) {
   String& str = String::Handle();
@@ skipping 6644 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart