Use Type* in crankshaft rather than HeapType.

src/accessors.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 11 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef V8_ACCESSORS_H_
 #define V8_ACCESSORS_H_
 
 #include "allocation.h"
+#include "types.h"
 #include "v8globals.h"
 
 namespace v8 {
 namespace internal {
 
 // The list of accessor descriptors. This is a second-order macro
 // taking a macro to be applied to all accessor descriptor names.
 #define ACCESSOR_DESCRIPTOR_LIST(V) \
   V(FunctionPrototype)              \
   V(FunctionLength)                 \
@@ skipping 37 matching lines @@
   // Accessor functions called directly from the runtime system.
   static Handle<Object> FunctionSetPrototype(Handle<JSFunction> object,
                                              Handle<Object> value);
   static Handle<Object> FunctionGetPrototype(Handle<JSFunction> object);
   static Handle<Object> FunctionGetArguments(Handle<JSFunction> object);
 
   // Accessor infos.
   static Handle<AccessorInfo> MakeModuleExport(
       Handle<String> name, int index, PropertyAttributes attributes);
 
+  static V8_INLINE bool CheckForName(Handle<String> name,
+                                     String* property_name,
+                                     int offset,
+                                     int* object_offset) {
+    if (name->Equals(property_name)) {
+      *object_offset = offset;
+      return true;
+    }
+    return false;
+  }
+
   // Returns true for properties that are accessors to object fields.
   // If true, *object_offset contains offset of object field.
-  static bool IsJSObjectFieldAccessor(
-      Handle<HeapType> map, Handle<String> name, int* object_offset);
+  template <class T>

[rossberg, 2014/02/03 16:54:05]

You don't necessarily need to move this to the header file. I'd keep the
implementation in the .cc and specialise the template to the only two types we
need.

+  static bool IsJSObjectFieldAccessor(typename T::TypeHandle type,
+                                      Handle<String> name,
+                                      int* object_offset) {
+    Isolate* isolate = name->GetIsolate();
 
+    if (type->Is(T::String())) {
+      return CheckForName(name, isolate->heap()->length_string(),
+                          String::kLengthOffset, object_offset);
+    }
+
+    if (!type->IsClass()) return false;
+    Handle<Map> map = type->AsClass();
+
+    switch (map->instance_type()) {
+      case JS_ARRAY_TYPE:
+        return
+          CheckForName(name, isolate->heap()->length_string(),
+                       JSArray::kLengthOffset, object_offset);
+      case JS_TYPED_ARRAY_TYPE:
+        return
+          CheckForName(name, isolate->heap()->length_string(),
+                       JSTypedArray::kLengthOffset, object_offset) ||
+          CheckForName(name, isolate->heap()->byte_length_string(),
+                       JSTypedArray::kByteLengthOffset, object_offset) ||
+          CheckForName(name, isolate->heap()->byte_offset_string(),
+                       JSTypedArray::kByteOffsetOffset, object_offset) ||
+          CheckForName(name, isolate->heap()->buffer_string(),
+                       JSTypedArray::kBufferOffset, object_offset);
+      case JS_ARRAY_BUFFER_TYPE:
+        return
+          CheckForName(name, isolate->heap()->byte_length_string(),
+                       JSArrayBuffer::kByteLengthOffset, object_offset);
+      case JS_DATA_VIEW_TYPE:
+        return
+          CheckForName(name, isolate->heap()->byte_length_string(),
+                       JSDataView::kByteLengthOffset, object_offset) ||
+          CheckForName(name, isolate->heap()->byte_offset_string(),
+                       JSDataView::kByteOffsetOffset, object_offset) ||
+          CheckForName(name, isolate->heap()->buffer_string(),
+                       JSDataView::kBufferOffset, object_offset);
+      default:
+        return false;
+    }
+  }
 
  private:
   // Accessor functions only used through the descriptor.
   static MaybeObject* FunctionSetPrototype(Isolate* isolate,
                                            JSObject* object,
                                            Object*,
                                            void*);
   static MaybeObject* FunctionGetPrototype(Isolate* isolate,
                                            Object* object,
                                            void*);
@@ skipping 52 matching lines @@
   static Object* IllegalGetAccessor(Isolate* isolate, Object* object, void*);
   static MaybeObject* ReadOnlySetAccessor(Isolate* isolate,
                                           JSObject*,
                                           Object* value,
                                           void*);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_ACCESSORS_H_