[es6] Partially implement Reflect.getOwnPropertyDescriptor.

src/property-descriptor.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/property-descriptor.h"
 
 #include "src/bootstrapper.h"
 #include "src/factory.h"
 #include "src/isolate-inl.h"
 #include "src/lookup.h"
@@ skipping 83 matching lines @@
   }
   if ((desc->has_get() || desc->has_set()) &&
       (desc->has_value() || desc->has_writable())) {
     // Bail out to slow path to throw an exception.
     return false;
   }
   return true;
 }
 
 
+static void CreateDataProperty(Isolate* isolate, Handle<JSObject> object,
+                               const char* name, Handle<Object> value) {
+  LookupIterator it(object,
+                    isolate->factory()->NewStringFromAsciiChecked(name));
+  Maybe<bool> result = JSObject::CreateDataProperty(&it, value);
+  CHECK(result.IsJust() && result.FromJust());
+}
+
+
+// ES6 6.2.4.4 "FromPropertyDescriptor"
+// We restrict ourselves to the case where the descriptor is either a complete
+// accessor descriptor or a complete data descriptor, as is true for the result
+// of JSReceiver::GetOwnPropertyDescriptor.
+Handle<Object> PropertyDescriptor::ToObject(Isolate* isolate) {
+  DCHECK(PropertyDescriptor::IsAccessorDescriptor(this) !=
+         PropertyDescriptor::IsDataDescriptor(this));
+  Handle<JSObject> result =
+      isolate->factory()->NewJSObject(isolate->object_function());
+  if (PropertyDescriptor::IsAccessorDescriptor(this)) {
+    DCHECK(has_get());
+    CreateDataProperty(isolate, result, "get", get());

[Jakob Kummerow, 2015/10/26 13:58:26]

I'm a bit concerned about the speed of building objects like this. It's probably
about 10x - 100x slower than using StoreICs. As a reference implementation, it's
OK for now because there is no easy alternative, but I suspect we'll want to
come up with a way to make it faster at some point.

+    DCHECK(has_set());
+    CreateDataProperty(isolate, result, "set", set());
+  } else {
+    DCHECK(has_value());
+    CreateDataProperty(isolate, result, "value", value());
+    DCHECK(has_writable());
+    CreateDataProperty(isolate, result, "writable",
+                       isolate->factory()->ToBoolean(writable()));
+  }
+  DCHECK(has_enumerable());
+  CreateDataProperty(isolate, result, "enumerable",
+                     isolate->factory()->ToBoolean(enumerable()));
+  DCHECK(has_configurable());
+  CreateDataProperty(isolate, result, "configurable",
+                     isolate->factory()->ToBoolean(configurable()));
+  return result;
+}
+
+
 // ES6 6.2.4.5
 // Returns false in case of exception.
 // static
 bool PropertyDescriptor::ToPropertyDescriptor(Isolate* isolate,
                                               Handle<Object> obj,
                                               PropertyDescriptor* desc) {
   // 1. ReturnIfAbrupt(Obj).
   // 2. If Type(Obj) is not Object, throw a TypeError exception.
   if (!obj->IsSpecObject()) {
     isolate->Throw(*isolate->factory()->NewTypeError(
@@ skipping 106 matching lines @@
         *isolate->factory()->NewTypeError(MessageTemplate::kUnsupported));
     return false;
   }
   // 23. Return desc.
   return true;
 }
 
 
 }  // namespace internal
 }  // namespace v8