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

vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/bitmap.h"
 #include "vm/dart.h"
 #include "vm/globals.h"
 #include "vm/handles.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/os.h"
 #include "vm/raw_object.h"
 #include "vm/scanner.h"
 
 namespace dart {
 
 // Forward declarations.
 #define DEFINE_FORWARD_DECLARATION(clazz)                                      \
   class clazz;
 CLASS_LIST(DEFINE_FORWARD_DECLARATION)
 #undef DEFINE_FORWARD_DECLARATION
 class Api;
 class Assembler;
+class Closure;
 class Code;
 class LocalScope;
 class Symbols;
 
 #define OBJECT_IMPLEMENTATION(object, super)                                   \
  public:  /* NOLINT */                                                         \
   Raw##object* raw() const { return reinterpret_cast<Raw##object*>(raw_); }    \
   void operator=(Raw##object* value) {                                         \
     initializeHandle(this, value);                                             \
   }                                                                            \
@@ skipping 374 matching lines @@
   static RawClass* context_scope_class_;  // Class of ContextScope vm object.
   static RawClass* icdata_class_;  // Class of ICData.
   static RawClass* subtypetestcache_class_;  // Class of SubtypeTestCache.
   static RawClass* api_error_class_;  // Class of ApiError.
   static RawClass* language_error_class_;  // Class of LanguageError.
   static RawClass* unhandled_exception_class_;  // Class of UnhandledException.
   static RawClass* unwind_error_class_;  // Class of UnwindError.
 
   friend void ClassTable::Register(const Class& cls);
   friend void RawObject::Validate(Isolate* isolate) const;
+  friend class Closure;
   friend class SnapshotReader;
 
   // Disallow allocation.
   void* operator new(size_t size);
   // Disallow copy constructor.
   DISALLOW_COPY_AND_ASSIGN(Object);
 };
 
 
 class Class : public Object {
@@ skipping 2568 matching lines @@
   }
 
   intptr_t GetNativeField(int index) const {
     return *NativeFieldAddr(index);
   }
 
   void SetNativeField(int index, intptr_t value) const {
     *NativeFieldAddr(index) = value;
   }
 
+  // Returns true if the instance is a closure object.
+  bool IsClosure() const;
+
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawInstance));
   }
 
   static RawInstance* New(const Class& cls, Heap::Space space = Heap::kNew);
 
  private:
   RawObject** FieldAddrAtOffset(intptr_t offset) const {
     ASSERT(IsValidFieldOffset(offset));
     return reinterpret_cast<RawObject**>(raw_value() - kHeapObjectTag + offset);
   }
   RawObject** FieldAddr(const Field& field) const {
     return FieldAddrAtOffset(field.Offset());
   }
   intptr_t* NativeFieldAddr(int index) const {
     ASSERT(IsValidNativeIndex(index));
     return reinterpret_cast<intptr_t*>((raw_value() - kHeapObjectTag)
                                        + (index * kWordSize)
                                        + sizeof(RawObject));
   }
   void SetFieldAtOffset(intptr_t offset, const Object& value) const {
     StorePointer(FieldAddrAtOffset(offset), value.raw());
   }
   bool IsValidFieldOffset(int offset) const;
 
   // TODO(iposva): Determine if this gets in the way of Smi.
   HEAP_OBJECT_IMPLEMENTATION(Instance, Object);
   friend class Class;
+  friend class Closure;
 };
 
 
 // AbstractType is an abstract superclass.
 // Subclasses of AbstractType are Type and TypeParameter.
 class AbstractType : public Instance {
  public:
   virtual bool IsFinalized() const;
   virtual bool IsBeingFinalized() const;
   virtual bool IsMalformed() const;
@@ skipping 2398 matching lines @@
 
 // DartFunction represents the abstract Dart class 'Function'.
 class DartFunction : public Instance {
  private:
   HEAP_OBJECT_IMPLEMENTATION(DartFunction, Instance);
   friend class Class;
   friend class Instance;
 };
 
 
-class Closure : public Instance {
+class Closure : public AllStatic {
  public:
-  RawFunction* function() const { return raw_ptr()->function_; }
+  static RawFunction* function(const Instance& closure) {
+    return *FunctionAddr(closure);
+  }
   static intptr_t function_offset() {
-    return OFFSET_OF(RawClosure, function_);
+    return static_cast<intptr_t>(kFunctionOffset * kWordSize);
   }
 
-  RawContext* context() const { return raw_ptr()->context_; }
-  static intptr_t context_offset() { return OFFSET_OF(RawClosure, context_); }
+  static RawContext* context(const Instance& closure) {
+    return *ContextAddr(closure);
+  }
+  static intptr_t context_offset() {
+    return static_cast<intptr_t>(kContextOffset * kWordSize);
+  }
 
-  virtual RawAbstractTypeArguments* GetTypeArguments() const {
-    return raw_ptr()->type_arguments_;
+  static RawAbstractTypeArguments* GetTypeArguments(const Instance& closure) {
+    return *TypeArgumentsAddr(closure);
   }
-  virtual void SetTypeArguments(const AbstractTypeArguments& value) const {
-    StorePointer(&raw_ptr()->type_arguments_, value.raw());
+  static void SetTypeArguments(const Instance& closure,
+                               const AbstractTypeArguments& value) {
+    closure.StorePointer(TypeArgumentsAddr(closure), value.raw());
   }
   static intptr_t type_arguments_offset() {
-    return OFFSET_OF(RawClosure, type_arguments_);
+    return static_cast<intptr_t>(kTypeArgumentsOffset * kWordSize);
   }
 
+  static const char* ToCString(const Instance& closure);
+
   static intptr_t InstanceSize() {
-    return RoundedAllocationSize(sizeof(RawClosure));
+    intptr_t size = sizeof(RawInstance) + (kNumFields * kWordSize);
+    ASSERT(size == Object::RoundedAllocationSize(size));
+    return size;
   }
 
-  static RawClosure* New(const Function& function,
-                         const Context& context,
-                         Heap::Space space = Heap::kNew);
+  static RawInstance* New(const Function& function,
+                          const Context& context,
+                          Heap::Space space = Heap::kNew);
 
  private:
-  void set_function(const Function& value) const;
-  void set_context(const Context& value) const;
+  static const int kTypeArgumentsOffset = 1;
+  static const int kFunctionOffset = 2;
+  static const int kContextOffset = 3;
+  static const int kNumFields = 3;
 
-  HEAP_OBJECT_IMPLEMENTATION(Closure, Instance);
+  static RawAbstractTypeArguments** TypeArgumentsAddr(const Instance& obj) {
+    ASSERT(obj.IsClosure());
+    return reinterpret_cast<RawAbstractTypeArguments**>(
+        reinterpret_cast<intptr_t>(obj.raw_ptr()) + type_arguments_offset());
+  }
+  static RawFunction** FunctionAddr(const Instance& obj) {
+    ASSERT(obj.IsClosure());
+    return reinterpret_cast<RawFunction**>(
+        reinterpret_cast<intptr_t>(obj.raw_ptr()) + function_offset());
+  }
+  static RawContext** ContextAddr(const Instance& obj) {
+    ASSERT(obj.IsClosure());
+    return reinterpret_cast<RawContext**>(
+        reinterpret_cast<intptr_t>(obj.raw_ptr()) + context_offset());
+  }
+  static void set_function(const Instance& closure,
+                           const Function& value) {
+    closure.StorePointer(FunctionAddr(closure), value.raw());
+  }
+  static void set_context(const Instance& closure,
+                          const Context& value) {
+    closure.StorePointer(ContextAddr(closure), value.raw());
+  }
+
   friend class Class;
 };
 
 
 // Internal stacktrace object used in exceptions for printing stack traces.
 class Stacktrace : public Instance {
  public:
   intptr_t Length() const;
   RawFunction* FunctionAtFrame(intptr_t frame_index) const;
   RawCode* CodeAtFrame(intptr_t frame_index) const;
@@ skipping 170 matching lines @@
   }
 #endif
   intptr_t cid = raw_->GetClassId();
   if (cid < kNumPredefinedCids) {
 #if defined(DEBUG)
     ASSERT(builtin_vtables_[cid] ==
            isolate->class_table()->At(cid)->ptr()->handle_vtable_);
 #endif
     set_vtable(builtin_vtables_[cid]);
   } else {
-#if !defined(DEBUG)
-    Isolate* isolate = Isolate::Current();
-#endif
-    RawClass* raw_class = isolate->class_table()->At(cid);
-    set_vtable(raw_class->ptr()->handle_vtable_);
+    set_vtable(builtin_vtables_[kInstanceCid]);
   }
 }
 
 
 bool Function::HasCode() const {
   return raw_ptr()->code_ != Code::null();
 }
 
 
 intptr_t Field::Offset() const {
@@ skipping 38 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_