Treat ExecutableAccessorInfo as regular data properties.

test/cctest/test-api.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 1906 matching lines @@
     Handle<Object> self = Handle<Object>::Cast(info.This());
     self->SetHiddenValue(name, value);
     info.GetReturnValue().Set(value);
   }
 }
 
 void AddAccessor(Handle<FunctionTemplate> templ,
                  Handle<String> name,
                  v8::AccessorGetterCallback getter,
                  v8::AccessorSetterCallback setter) {
-  templ->PrototypeTemplate()->SetAccessor(name, getter, setter);
+  templ->InstanceTemplate()->SetAccessor(name, getter, setter);
 }
 
 void AddInterceptor(Handle<FunctionTemplate> templ,
                     v8::NamedPropertyGetterCallback getter,
                     v8::NamedPropertySetterCallback setter) {
   templ->InstanceTemplate()->SetNamedPropertyHandler(getter, setter);
 }
 
 
 THREADED_TEST(EmptyInterceptorDoesNotShadowAccessors) {
   v8::HandleScope scope(CcTest::isolate());
   Handle<FunctionTemplate> parent = FunctionTemplate::New(CcTest::isolate());
+  parent->SetHiddenPrototype(true);
   Handle<FunctionTemplate> child = FunctionTemplate::New(CcTest::isolate());
   child->Inherit(parent);
   AddAccessor(parent, v8_str("age"),
               SimpleAccessorGetter, SimpleAccessorSetter);
   AddInterceptor(child, EmptyInterceptorGetter, EmptyInterceptorSetter);
   LocalContext env;
   env->Global()->Set(v8_str("Child"), child->GetFunction());
   CompileRun("var child = new Child;"
              "child.age = 10;");
-  ExpectBoolean("child.hasOwnProperty('age')", false);
+  ExpectBoolean("child.hasOwnProperty('age')", true);
   ExpectInt32("child.age", 10);
   ExpectInt32("child.accessor_age", 10);
 }
 
 
 THREADED_TEST(ExecutableAccessorIsPreservedOnAttributeChange) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   LocalContext env;
   v8::Local<v8::Value> res = CompileRun("var a = []; a;");
@@ skipping 8018 matching lines @@
 
 THREADED_TEST(ShadowObject) {
   shadow_y = shadow_y_setter_call_count = shadow_y_getter_call_count = 0;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<ObjectTemplate> global_template = v8::ObjectTemplate::New(isolate);
   LocalContext context(NULL, global_template);
 
   Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate);
-  t->InstanceTemplate()->SetNamedPropertyHandler(ShadowNamedGet);
-  t->InstanceTemplate()->SetIndexedPropertyHandler(ShadowIndexedGet);
-  Local<ObjectTemplate> proto = t->PrototypeTemplate();
+  t->SetHiddenPrototype(true);
+  Local<v8::FunctionTemplate> pt = v8::FunctionTemplate::New(isolate);
+  t->Inherit(pt);
+  Local<ObjectTemplate> proto = pt->PrototypeTemplate();
   Local<ObjectTemplate> instance = t->InstanceTemplate();
+  instance->SetNamedPropertyHandler(ShadowNamedGet);
+  instance->SetIndexedPropertyHandler(ShadowIndexedGet);
 
   proto->Set(v8_str("f"),
              v8::FunctionTemplate::New(isolate,
                                        ShadowFunctionCallback,
                                        Local<Value>()));
   proto->Set(v8_str("x"), v8_num(12));
 
   instance->SetAccessor(v8_str("y"), ShadowYGetter, ShadowYSetter);
 
   Local<Value> o = t->GetFunction()->NewInstance();
@@ skipping 8525 matching lines @@
   CHECK(v8::Utils::OpenHandle(*info.Holder())->IsJSObject());
   if (!name->Equals(v8_str("foo"))) return;
   Local<Object>::Cast(info.This())->Set(v8_str("y"), v8_num(23));
   info.GetReturnValue().Set(v8_num(23));
 }
 
 
 TEST(SetterOnConstructorPrototype) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
-  templ->SetAccessor(v8_str("x"),
-                     GetterWhichReturns42,
-                     SetterWhichSetsYOnThisTo23);
+  Local<FunctionTemplate> templ = FunctionTemplate::New(isolate);
+  templ->SetHiddenPrototype(true);
+  templ->InstanceTemplate()->SetAccessor(
+      v8_str("x"), GetterWhichReturns42, SetterWhichSetsYOnThisTo23);
   LocalContext context;
-  context->Global()->Set(v8_str("P"), templ->NewInstance());
+  context->Global()->Set(v8_str("P"), templ->InstanceTemplate()->NewInstance());
   CompileRun("function C1() {"
              "  this.x = 23;"
              "};"
              "C1.prototype = P;"
              "function C2() {"
              "  this.x = 23"
              "};"
              "C2.prototype = { };"
              "C2.prototype.__proto__ = P;");
 
   v8::Local<v8::Script> script;
   script = v8_compile("new C1();");
   for (int i = 0; i < 10; i++) {
     v8::Handle<v8::Object> c1 = v8::Handle<v8::Object>::Cast(script->Run());
     CHECK_EQ(42, c1->Get(v8_str("x"))->Int32Value());
     CHECK_EQ(23, c1->Get(v8_str("y"))->Int32Value());
   }
 
 script = v8_compile("new C2();");
   for (int i = 0; i < 10; i++) {
     v8::Handle<v8::Object> c2 = v8::Handle<v8::Object>::Cast(script->Run());
-    CHECK_EQ(42, c2->Get(v8_str("x"))->Int32Value());
-    CHECK_EQ(23, c2->Get(v8_str("y"))->Int32Value());
+    CHECK_EQ(23, c2->Get(v8_str("x"))->Int32Value());
   }
 }
 
 
 static void NamedPropertyGetterWhichReturns42(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(v8_num(42));
 }
 
@@ skipping 65 matching lines @@
   script = v8_compile("new C1();");
   // Allow enough iterations for the inobject slack tracking logic
   // to finalize instance size and install the fast construct stub.
   for (int i = 0; i < 256; i++) {
     v8::Handle<v8::Object> c1 = v8::Handle<v8::Object>::Cast(script->Run());
     CHECK_EQ(23, c1->Get(v8_str("x"))->Int32Value());
     CHECK_EQ(42, c1->Get(v8_str("y"))->Int32Value());
   }
 
   // Use an API object with accessors as prototype.
-  Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
-  templ->SetAccessor(v8_str("x"),
-                     GetterWhichReturns42,
-                     SetterWhichSetsYOnThisTo23);
-  context->Global()->Set(v8_str("P"), templ->NewInstance());
+  Local<FunctionTemplate> templ = FunctionTemplate::New(isolate);
+  templ->SetHiddenPrototype(true);
+  templ->InstanceTemplate()->SetAccessor(
+      v8_str("x"), GetterWhichReturns42, SetterWhichSetsYOnThisTo23);
+  context->Global()->Set(v8_str("P"), templ->InstanceTemplate()->NewInstance());
 
   // This compile will get the code from the compilation cache.
   CompileRun(source);
 
   script = v8_compile("new C1();");
   for (int i = 0; i < 10; i++) {
     v8::Handle<v8::Object> c1 = v8::Handle<v8::Object>::Cast(script->Run());
     CHECK_EQ(42, c1->Get(v8_str("x"))->Int32Value());
     CHECK_EQ(23, c1->Get(v8_str("y"))->Int32Value());
   }
@@ skipping 2393 matching lines @@
                       const v8::PropertyCallbackInfo<void>& info) {
   CHECK_EQ(name, v8_str("foo"));
   CHECK_EQ(value, v8_num(23));
   instance_checked_setter_count++;
 }
 
 
 static void CheckInstanceCheckedResult(int getters,
                                        int setters,
                                        bool expects_callbacks,
+                                       bool is_setter,
                                        TryCatch* try_catch) {
   if (expects_callbacks) {
     CHECK(!try_catch->HasCaught());
     CHECK_EQ(getters, instance_checked_getter_count);
     CHECK_EQ(setters, instance_checked_setter_count);
   } else {
-    CHECK(try_catch->HasCaught());
+    CHECK((is_setter && !try_catch->HasCaught()) ||
+          (!is_setter && try_catch->HasCaught()));
     CHECK_EQ(0, instance_checked_getter_count);
     CHECK_EQ(0, instance_checked_setter_count);
   }
   try_catch->Reset();
 }
 
 
 static void CheckInstanceCheckedAccessors(bool expects_callbacks) {
   instance_checked_getter_count = 0;
   instance_checked_setter_count = 0;
   TryCatch try_catch;
 
   // Test path through generic runtime code.
   CompileRun("obj.foo");
-  CheckInstanceCheckedResult(1, 0, expects_callbacks, &try_catch);
+  CheckInstanceCheckedResult(1, 0, expects_callbacks, false, &try_catch);
   CompileRun("obj.foo = 23");
-  CheckInstanceCheckedResult(1, 1, expects_callbacks, &try_catch);
+  CheckInstanceCheckedResult(1, 1, expects_callbacks, true, &try_catch);
+  if (!expects_callbacks) CompileRun("delete obj.foo");
 
   // Test path through generated LoadIC and StoredIC.
   CompileRun("function test_get(o) { o.foo; }"
              "test_get(obj);");
-  CheckInstanceCheckedResult(2, 1, expects_callbacks, &try_catch);
+  CheckInstanceCheckedResult(2, 1, expects_callbacks, false, &try_catch);
   CompileRun("test_get(obj);");
-  CheckInstanceCheckedResult(3, 1, expects_callbacks, &try_catch);
+  CheckInstanceCheckedResult(3, 1, expects_callbacks, false, &try_catch);
   CompileRun("test_get(obj);");
-  CheckInstanceCheckedResult(4, 1, expects_callbacks, &try_catch);
+  CheckInstanceCheckedResult(4, 1, expects_callbacks, false, &try_catch);
   CompileRun("function test_set(o) { o.foo = 23; }"
              "test_set(obj);");
-  CheckInstanceCheckedResult(4, 2, expects_callbacks, &try_catch);
+  CheckInstanceCheckedResult(4, 2, expects_callbacks, true, &try_catch);
+  if (!expects_callbacks) CompileRun("delete obj.foo");
   CompileRun("test_set(obj);");
-  CheckInstanceCheckedResult(4, 3, expects_callbacks, &try_catch);
+  CheckInstanceCheckedResult(4, 3, expects_callbacks, true, &try_catch);
+  if (!expects_callbacks) CompileRun("delete obj.foo");
   CompileRun("test_set(obj);");
-  CheckInstanceCheckedResult(4, 4, expects_callbacks, &try_catch);
+  CheckInstanceCheckedResult(4, 4, expects_callbacks, true, &try_catch);
+  if (!expects_callbacks) CompileRun("delete obj.foo");
 
   // Test path through optimized code.
   CompileRun("%OptimizeFunctionOnNextCall(test_get);"
              "test_get(obj);");
-  CheckInstanceCheckedResult(5, 4, expects_callbacks, &try_catch);
+  CheckInstanceCheckedResult(5, 4, expects_callbacks, false, &try_catch);
   CompileRun("%OptimizeFunctionOnNextCall(test_set);"
              "test_set(obj);");
-  CheckInstanceCheckedResult(5, 5, expects_callbacks, &try_catch);
+  if (!expects_callbacks) CompileRun("delete obj.foo");
+  CheckInstanceCheckedResult(5, 5, expects_callbacks, true, &try_catch);
 
   // Cleanup so that closures start out fresh in next check.
   CompileRun("%DeoptimizeFunction(test_get);"
              "%ClearFunctionTypeFeedback(test_get);"
              "%DeoptimizeFunction(test_set);"
              "%ClearFunctionTypeFeedback(test_set);");
 }
 
 
 THREADED_TEST(InstanceCheckOnInstanceAccessor) {
@@ skipping 51 matching lines @@
   CHECK(!templ->HasInstance(context->Global()->Get(v8_str("obj"))));
   CheckInstanceCheckedAccessors(false);
 }
 
 
 THREADED_TEST(InstanceCheckOnPrototypeAccessor) {
   v8::internal::FLAG_allow_natives_syntax = true;
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
-  Local<FunctionTemplate> templ = FunctionTemplate::New(context->GetIsolate());
-  Local<ObjectTemplate> proto = templ->PrototypeTemplate();
+  Local<FunctionTemplate> proto_templ =
+      FunctionTemplate::New(context->GetIsolate());
+  proto_templ->SetHiddenPrototype(true);
+  Local<ObjectTemplate> proto = proto_templ->InstanceTemplate();
   proto->SetAccessor(v8_str("foo"),
                      InstanceCheckedGetter, InstanceCheckedSetter,
                      Handle<Value>(),
                      v8::DEFAULT,
                      v8::None,
-                     v8::AccessorSignature::New(context->GetIsolate(), templ));
+                     v8::AccessorSignature::New(context->GetIsolate(),
+                                                proto_templ));
+  Local<FunctionTemplate> templ =
+      FunctionTemplate::New(context->GetIsolate());
+  templ->Inherit(proto_templ);
   context->Global()->Set(v8_str("f"), templ->GetFunction());
 
   printf("Testing positive ...\n");
   CompileRun("var obj = new f();");
   CHECK(templ->HasInstance(context->Global()->Get(v8_str("obj"))));
   CheckInstanceCheckedAccessors(true);
 
   printf("Testing negative ...\n");
   CompileRun("var obj = {};"
              "obj.__proto__ = new f();");
@@ skipping 1656 matching lines @@
   SourceURLHelper("function foo() {}\n"
                   "//# sourceURL=bar19\".js   \n"
                   "//# sourceMappingURL=bar20\".js \n",
                   NULL, NULL);
 
   // Not too much whitespace.
   SourceURLHelper("function foo() {}\n"
                   "//# sourceURL=  bar21.js   \n"
                   "//# sourceMappingURL=  bar22.js \n", "bar21.js", "bar22.js");
 }