load ics for js api accessors

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 123 matching lines @@
 }
 
 
 static void ExpectUndefined(const char* code) {
   Local<Value> result = CompileRun(code);
   CHECK(result->IsUndefined());
 }
 
 
 static int signature_callback_count;
+static Local<Value> signature_expected_receiver;
 static void IncrementingSignatureCallback(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   signature_callback_count++;
+  CHECK_EQ(signature_expected_receiver, args.Holder());
+  CHECK_EQ(signature_expected_receiver, args.This());
   v8::Handle<v8::Array> result = v8::Array::New(args.Length());
   for (int i = 0; i < args.Length(); i++)
     result->Set(v8::Integer::New(i), args[i]);
   args.GetReturnValue().Set(result);
 }
 
 
 static void SignatureCallback(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
@@ skipping 48 matching lines @@
 THREADED_TEST(ReceiverSignature) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Handle<v8::FunctionTemplate> fun = v8::FunctionTemplate::New();
   v8::Handle<v8::Signature> sig = v8::Signature::New(fun);
   fun->PrototypeTemplate()->Set(
       v8_str("m"),
       v8::FunctionTemplate::New(IncrementingSignatureCallback,
                                 v8::Handle<Value>(),
                                 sig));
+  fun->PrototypeTemplate()->SetAccessorProperty(
+      v8_str("n"),
+      v8::FunctionTemplate::New(IncrementingSignatureCallback,
+                                v8::Handle<Value>(),
+                                sig));
   env->Global()->Set(v8_str("Fun"), fun->GetFunction());
+  Local<Value> fun_instance = fun->InstanceTemplate()->NewInstance();
+  env->Global()->Set(v8_str("fun_instance"), fun_instance);
   signature_callback_count = 0;
+  int expected_count = 0;
+  signature_expected_receiver = fun_instance;
   CompileRun(
-      "var o = new Fun();"
-      "o.m();");
-  CHECK_EQ(1, signature_callback_count);
+      "var o = fun_instance;"
+      "var key_n = 'n';"
+      "for (var i = 0; i < 10; i++) o.m();"
+      "for (var i = 0; i < 10; i++) o.n;"
+      "for (var i = 0; i < 10; i++) o[key_n];");
+  expected_count += 30;
+  CHECK_EQ(expected_count, signature_callback_count);
   v8::Handle<v8::FunctionTemplate> sub_fun = v8::FunctionTemplate::New();
   sub_fun->Inherit(fun);
-  env->Global()->Set(v8_str("SubFun"), sub_fun->GetFunction());
+  fun_instance = sub_fun->InstanceTemplate()->NewInstance();
+  env->Global()->Set(v8_str("fun_instance"), fun_instance);
+  signature_expected_receiver = fun_instance;
   CompileRun(
-      "var o = new SubFun();"
-      "o.m();");
-  CHECK_EQ(2, signature_callback_count);
-
+      "var o = fun_instance;"
+      "var key_n = 'n';"
+      "for (var i = 0; i < 10; i++) o.m();"
+      "for (var i = 0; i < 10; i++) o.n;"
+      "for (var i = 0; i < 10; i++) o[key_n];");
+  expected_count += 30;
+  CHECK_EQ(expected_count, signature_callback_count);
   v8::TryCatch try_catch;
   CompileRun(
       "var o = { };"
       "o.m = Fun.prototype.m;"
       "o.m();");
-  CHECK_EQ(2, signature_callback_count);
+  CHECK_EQ(expected_count, signature_callback_count);
+  CHECK(try_catch.HasCaught());
+  CompileRun(
+      "var o = { };"
+      "o.n = Fun.prototype.n;"
+      "o.n;");
+  CHECK_EQ(expected_count, signature_callback_count);
   CHECK(try_catch.HasCaught());
   try_catch.Reset();
   v8::Handle<v8::FunctionTemplate> unrel_fun = v8::FunctionTemplate::New();
   sub_fun->Inherit(fun);
   env->Global()->Set(v8_str("UnrelFun"), unrel_fun->GetFunction());
   CompileRun(
       "var o = new UnrelFun();"
       "o.m = Fun.prototype.m;"
       "o.m();");
-  CHECK_EQ(2, signature_callback_count);
+  CHECK_EQ(expected_count, signature_callback_count);
+  CHECK(try_catch.HasCaught());
+  try_catch.Reset();
+  CompileRun(
+      "var o = new UnrelFun();"
+      "o.n = Fun.prototype.n;"
+      "o.n;");
+  CHECK_EQ(expected_count, signature_callback_count);
   CHECK(try_catch.HasCaught());
 }
 
 
 THREADED_TEST(ArgumentSignature) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Handle<v8::FunctionTemplate> cons = v8::FunctionTemplate::New();
   cons->SetClassName(v8_str("Cons"));
   v8::Handle<v8::Signature> sig =
@@ skipping 20157 matching lines @@
              "setAge(100);"
              "setAge(101);"
              "setAge(102);"
              "%OptimizeFunctionOnNextCall(setAge);"
              "setAge(103);");
   ExpectInt32("obj.age", 100000);
   ExpectInt32("obj.interceptor_age", 103);
 }
 
 #endif  // V8_OS_POSIX