js accessor creation on Template

test/cctest/test-accessors.cc

 // 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 33 matching lines @@
 using ::v8::AccessorInfo;
 using ::v8::Extension;
 
 static void handle_property(Local<String> name,
                             const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   info.GetReturnValue().Set(v8_num(900));
 }
 
 
+static void handle_property(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  ApiTestFuzzer::Fuzz();
+  CHECK_EQ(0, info.Length());
+  info.GetReturnValue().Set(v8_num(907));
+}
+
+
 THREADED_TEST(PropertyHandler) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New();
   fun_templ->InstanceTemplate()->SetAccessor(v8_str("foo"), handle_property);
+  Local<v8::FunctionTemplate> getter_templ =
+      v8::FunctionTemplate::New(handle_property);
+  getter_templ->SetLength(0);
+  fun_templ->
+      InstanceTemplate()->SetAccessorProperty(v8_str("bar"), getter_templ);
   Local<Function> fun = fun_templ->GetFunction();
   env->Global()->Set(v8_str("Fun"), fun);
   Local<Script> getter = v8_compile("var obj = new Fun(); obj.foo;");
   CHECK_EQ(900, getter->Run()->Int32Value());
   Local<Script> setter = v8_compile("obj.foo = 901;");
   CHECK_EQ(901, setter->Run()->Int32Value());
+  getter = v8_compile("obj.bar;");
+  CHECK_EQ(907, getter->Run()->Int32Value());
+  setter = v8_compile("obj.bar = 908;");
+  CHECK_EQ(908, setter->Run()->Int32Value());
 }
 
 
 static void GetIntValue(Local<String> property,
                         const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   int* value =
       static_cast<int*>(v8::Handle<v8::External>::Cast(info.Data())->Value());
   info.GetReturnValue().Set(v8_num(*value));
 }
@@ skipping 27 matching lines @@
                                          GetIntValue,
                                          SetIntValue,
                                          v8::External::New(&baz));
   LocalContext env(0, templ->InstanceTemplate());
   v8_compile("foo = (++bar) + baz")->Run();
   CHECK_EQ(bar, -3);
   CHECK_EQ(foo, 7);
 }
 
 
-static int x_register = 0;
+static int x_register[2] = {0, 0};
 static v8::Handle<v8::Object> x_receiver;
 static v8::Handle<v8::Object> x_holder;
 
+template<class Info>
+static void XGetter(const Info& info, int offset) {
+  ApiTestFuzzer::Fuzz();
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  CHECK_EQ(isolate, info.GetIsolate());
+  CHECK_EQ(x_receiver, info.This());
+  info.GetReturnValue().Set(v8_num(x_register[offset]));
+}
+
 
 static void XGetter(Local<String> name,
                     const v8::PropertyCallbackInfo<v8::Value>& info) {
-  ApiTestFuzzer::Fuzz();
+  CHECK_EQ(x_holder, info.Holder());
+  XGetter(info, 0);
+}
+
+
+static void XGetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  XGetter(info, 1);
+}
+
+
+template<class Info>
+static void XSetter(Local<Value> value, const Info& info, int offset) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   CHECK_EQ(isolate, info.GetIsolate());
-  CHECK_EQ(x_receiver, info.This());
-  CHECK_EQ(x_holder, info.Holder());
-  info.GetReturnValue().Set(v8_num(x_register));
+  CHECK_EQ(x_holder, info.This());
+  x_register[offset] = value->Int32Value();
 }
 
 
 static void XSetter(Local<String> name,
                     Local<Value> value,
                     const v8::PropertyCallbackInfo<void>& info) {
-  v8::Isolate* isolate = v8::Isolate::GetCurrent();
-  CHECK_EQ(isolate, info.GetIsolate());
-  CHECK_EQ(x_holder, info.This());
   CHECK_EQ(x_holder, info.Holder());
-  x_register = value->Int32Value();
+  XSetter(value, info, 0);
 }
 
 
+static void XSetter(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  CHECK_EQ(1, info.Length());
+  XSetter(info[0], info, 1);
+}
+
+
 THREADED_TEST(AccessorIC) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New();
-  obj->SetAccessor(v8_str("x"), XGetter, XSetter);
+  obj->SetAccessor(v8_str("x0"), XGetter, XSetter);
+  obj->SetAccessorProperty(v8_str("x1"),
+                           v8::FunctionTemplate::New(XGetter),
+                           v8::FunctionTemplate::New(XSetter));
   x_holder = obj->NewInstance();
   context->Global()->Set(v8_str("holder"), x_holder);
   x_receiver = v8::Object::New();
   context->Global()->Set(v8_str("obj"), x_receiver);
   v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(CompileRun(
     "obj.__proto__ = holder;"
     "var result = [];"
     "for (var i = 0; i < 10; i++) {"
-    "  holder.x = i;"
-    "  result.push(obj.x);"
+    "  holder.x0 = i;"
+    "  holder.x1 = i;"
+    "  result.push(obj.x0);"
+    "  result.push(obj.x1);"
     "}"
     "result"));
-  CHECK_EQ(10, array->Length());
-  for (int i = 0; i < 10; i++) {
+  CHECK_EQ(20, array->Length());
+  for (int i = 0; i < 20; i++) {
     v8::Handle<Value> entry = array->Get(v8::Integer::New(i));
-    CHECK_EQ(v8::Integer::New(i), entry);
+    CHECK_EQ(v8::Integer::New(i/2), entry);
   }
 }
 
 
 static void AccessorProhibitsOverwritingGetter(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   info.GetReturnValue().Set(true);
 }
@@ skipping 308 matching lines @@
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New();
   obj->SetNamedPropertyHandler(
       JSONStringifyGetter, NULL, NULL, NULL, JSONStringifyEnumerator);
   env->Global()->Set(v8_str("obj"), obj->NewInstance());
   v8::Handle<v8::String> expected = v8_str("{\"regress\":\"crbug-161028\"}");
   CHECK(CompileRun("JSON.stringify(obj)")->Equals(expected));
 }