Revert "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->InstanceTemplate()->SetAccessor(name, getter, setter);
+  templ->PrototypeTemplate()->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')", true);
+  ExpectBoolean("child.hasOwnProperty('age')", false);
   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->SetHiddenPrototype(true);
-  Local<v8::FunctionTemplate> pt = v8::FunctionTemplate::New(isolate);
-  t->Inherit(pt);
-  Local<ObjectTemplate> proto = pt->PrototypeTemplate();
+  t->InstanceTemplate()->SetNamedPropertyHandler(ShadowNamedGet);
+  t->InstanceTemplate()->SetIndexedPropertyHandler(ShadowIndexedGet);
+  Local<ObjectTemplate> proto = t->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 8526 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<FunctionTemplate> templ = FunctionTemplate::New(isolate);
-  templ->SetHiddenPrototype(true);
-  templ->InstanceTemplate()->SetAccessor(v8_str("x"), GetterWhichReturns42,
-                                         SetterWhichSetsYOnThisTo23);
+  Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+  templ->SetAccessor(v8_str("x"), GetterWhichReturns42,
+                     SetterWhichSetsYOnThisTo23);
   LocalContext context;
-  context->Global()->Set(v8_str("P"), templ->InstanceTemplate()->NewInstance());
+  context->Global()->Set(v8_str("P"), templ->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(23, c2->Get(v8_str("x"))->Int32Value());
+    CHECK_EQ(42, c2->Get(v8_str("x"))->Int32Value());
+    CHECK_EQ(23, c2->Get(v8_str("y"))->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<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());
+  Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+  templ->SetAccessor(v8_str("x"), GetterWhichReturns42,
+                     SetterWhichSetsYOnThisTo23);
+  context->Global()->Set(v8_str("P"), templ->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 2394 matching lines @@
 static void InstanceCheckedSetter(Local<String> name,
                       Local<Value> value,
                       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,
+                                       bool expects_callbacks,
                                        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((is_setter && !try_catch->HasCaught()) ||
-          (!is_setter && try_catch->HasCaught()));
+    CHECK(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, false, &try_catch);
+  CheckInstanceCheckedResult(1, 0, expects_callbacks, &try_catch);
   CompileRun("obj.foo = 23");
-  CheckInstanceCheckedResult(1, 1, expects_callbacks, true, &try_catch);
-  if (!expects_callbacks) CompileRun("delete obj.foo");
+  CheckInstanceCheckedResult(1, 1, expects_callbacks, &try_catch);
 
   // Test path through generated LoadIC and StoredIC.
   CompileRun("function test_get(o) { o.foo; }"
              "test_get(obj);");
-  CheckInstanceCheckedResult(2, 1, expects_callbacks, false, &try_catch);
+  CheckInstanceCheckedResult(2, 1, expects_callbacks, &try_catch);
   CompileRun("test_get(obj);");
-  CheckInstanceCheckedResult(3, 1, expects_callbacks, false, &try_catch);
+  CheckInstanceCheckedResult(3, 1, expects_callbacks, &try_catch);
   CompileRun("test_get(obj);");
-  CheckInstanceCheckedResult(4, 1, expects_callbacks, false, &try_catch);
+  CheckInstanceCheckedResult(4, 1, expects_callbacks, &try_catch);
   CompileRun("function test_set(o) { o.foo = 23; }"
              "test_set(obj);");
-  CheckInstanceCheckedResult(4, 2, expects_callbacks, true, &try_catch);
-  if (!expects_callbacks) CompileRun("delete obj.foo");
+  CheckInstanceCheckedResult(4, 2, expects_callbacks, &try_catch);
   CompileRun("test_set(obj);");
-  CheckInstanceCheckedResult(4, 3, expects_callbacks, true, &try_catch);
-  if (!expects_callbacks) CompileRun("delete obj.foo");
+  CheckInstanceCheckedResult(4, 3, expects_callbacks, &try_catch);
   CompileRun("test_set(obj);");
-  CheckInstanceCheckedResult(4, 4, expects_callbacks, true, &try_catch);
-  if (!expects_callbacks) CompileRun("delete obj.foo");
+  CheckInstanceCheckedResult(4, 4, expects_callbacks, &try_catch);
 
   // Test path through optimized code.
   CompileRun("%OptimizeFunctionOnNextCall(test_get);"
              "test_get(obj);");
-  CheckInstanceCheckedResult(5, 4, expects_callbacks, false, &try_catch);
+  CheckInstanceCheckedResult(5, 4, expects_callbacks, &try_catch);
   CompileRun("%OptimizeFunctionOnNextCall(test_set);"
              "test_set(obj);");
-  if (!expects_callbacks) CompileRun("delete obj.foo");
-  CheckInstanceCheckedResult(5, 5, expects_callbacks, true, &try_catch);
+  CheckInstanceCheckedResult(5, 5, expects_callbacks, &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> 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(), proto_templ));
   Local<FunctionTemplate> templ = FunctionTemplate::New(context->GetIsolate());
-  templ->Inherit(proto_templ);
+  Local<ObjectTemplate> proto = templ->PrototypeTemplate();
+  proto->SetAccessor(v8_str("foo"), InstanceCheckedGetter,
+                     InstanceCheckedSetter, Handle<Value>(), v8::DEFAULT,
+                     v8::None,
+                     v8::AccessorSignature::New(context->GetIsolate(), 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 1684 matching lines @@
   desc = x->GetOwnPropertyDescriptor(v8_str("p1"));
   Local<Function> set =
     Local<Function>::Cast(Local<Object>::Cast(desc)->Get(v8_str("set")));
   Local<Function> get =
     Local<Function>::Cast(Local<Object>::Cast(desc)->Get(v8_str("get")));
   CHECK_EQ(v8_num(13), get->Call(x, 0, NULL));
   Handle<Value> args[] = { v8_num(14) };
   set->Call(x, 1, args);
   CHECK_EQ(v8_num(14), get->Call(x, 0, NULL));
 }