Map v8::Function to JSReceiver + IsCallable

test/cctest/test-compiler.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 280 matching lines @@
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_crankshaft()) return;
   v8::HandleScope scope(CcTest::isolate());
 
   // Make sure function f has a call that uses a type feedback slot.
   CompileRun("function fun() {};"
              "fun1 = fun;"
              "function f(a) { a(); } f(fun1);");
 
-  Handle<JSFunction> f =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Function>::Cast(
-              CcTest::global()->Get(v8_str("f"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
 
   // We shouldn't have deoptimization support. We want to recompile and
   // verify that our feedback vector preserves information.
   CHECK(!f->shared()->has_deoptimization_support());
   Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
 
   // Verify that we gathered feedback.
   CHECK(!feedback_vector->is_empty());
   FeedbackVectorSlot slot_for_a(0);
   Object* object = feedback_vector->Get(slot_for_a);
@@ skipping 22 matching lines @@
              "  return (function() {"
              "    eval('');"
              "    return function() {"
              "      'use strict';"
              "      call_target();"
              "    }"
              "  })();"
              "}"
              "morphing_call = builder();");
 
-  Handle<JSFunction> f =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Function>::Cast(
-              CcTest::global()->Get(v8_str("morphing_call"))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Handle<v8::Function>::Cast(
+          CcTest::global()->Get(v8_str("morphing_call")))));
 
   // Not compiled, and so no feedback vector allocated yet.
   CHECK(!f->shared()->is_compiled());
   CHECK(f->shared()->feedback_vector()->is_empty());
 
   CompileRun("morphing_call();");
 
   // Now a feedback vector is allocated.
   CHECK(f->shared()->is_compiled());
   CHECK(!f->shared()->feedback_vector()->is_empty());
@@ skipping 14 matching lines @@
     CompileRun(
         "function MakeClosure() {"
         "  return function() { return x; };"
         "}"
         "var closure0 = MakeClosure();"
         "%DebugPrint(closure0());"
         "%OptimizeFunctionOnNextCall(closure0);"
         "%DebugPrint(closure0());"
         "var closure1 = MakeClosure();"
         "var closure2 = MakeClosure();");
-    Handle<JSFunction> fun1 = v8::Utils::OpenHandle(
-        *v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("closure1"))));
-    Handle<JSFunction> fun2 = v8::Utils::OpenHandle(
-        *v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("closure2"))));
+    Handle<JSFunction> fun1 = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            env->Global()->Get(v8_str("closure1")))));
+    Handle<JSFunction> fun2 = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            env->Global()->Get(v8_str("closure2")))));
     CHECK(fun1->IsOptimized() || !CcTest::i_isolate()->use_crankshaft());
     CHECK(fun2->IsOptimized() || !CcTest::i_isolate()->use_crankshaft());
     CHECK_EQ(fun1->code(), fun2->code());
   }
 }
 
 
 // Test that optimized code for different closures is actually shared
 // immediately by the FastNewClosureStub when run different contexts.
 TEST(OptimizedCodeSharing2) {
@@ skipping 13 matching lines @@
   {
     LocalContext env;
     env->Global()->Set(v8::String::NewFromUtf8(CcTest::isolate(), "x"),
                        v8::Integer::New(CcTest::isolate(), 23));
     script->GetUnboundScript()->BindToCurrentContext()->Run();
     CompileRun(
         "var closure0 = MakeClosure();"
         "%DebugPrint(closure0());"
         "%OptimizeFunctionOnNextCall(closure0);"
         "%DebugPrint(closure0());");
-    Handle<JSFunction> fun0 = v8::Utils::OpenHandle(
-        *v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("closure0"))));
+    Handle<JSFunction> fun0 = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            env->Global()->Get(v8_str("closure0")))));
     CHECK(fun0->IsOptimized() || !CcTest::i_isolate()->use_crankshaft());
     reference_code = handle(fun0->code());
   }
   for (int i = 0; i < 3; i++) {
     LocalContext env;
     env->Global()->Set(v8::String::NewFromUtf8(CcTest::isolate(), "x"),
                        v8::Integer::New(CcTest::isolate(), i));
     script->GetUnboundScript()->BindToCurrentContext()->Run();
     CompileRun(
         "var closure0 = MakeClosure();"
         "%DebugPrint(closure0());"
         "%OptimizeFunctionOnNextCall(closure0);"
         "%DebugPrint(closure0());"
         "var closure1 = MakeClosure();"
         "var closure2 = MakeClosure();");
-    Handle<JSFunction> fun1 = v8::Utils::OpenHandle(
-        *v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("closure1"))));
-    Handle<JSFunction> fun2 = v8::Utils::OpenHandle(
-        *v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("closure2"))));
+    Handle<JSFunction> fun1 = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            env->Global()->Get(v8_str("closure1")))));
+    Handle<JSFunction> fun2 = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            env->Global()->Get(v8_str("closure2")))));
     CHECK(fun1->IsOptimized() || !CcTest::i_isolate()->use_crankshaft());
     CHECK(fun2->IsOptimized() || !CcTest::i_isolate()->use_crankshaft());
     CHECK_EQ(*reference_code, fun1->code());
     CHECK_EQ(*reference_code, fun2->code());
   }
 }
 
 
 // Test that optimized code for different closures is actually shared
 // immediately by the FastNewClosureStub without context-dependent entries.
@@ skipping 14 matching lines @@
   {
     LocalContext env;
     env->Global()->Set(v8::String::NewFromUtf8(CcTest::isolate(), "x"),
                        v8::Integer::New(CcTest::isolate(), 23));
     script->GetUnboundScript()->BindToCurrentContext()->Run();
     CompileRun(
         "var closure0 = MakeClosure();"
         "%DebugPrint(closure0());"
         "%OptimizeFunctionOnNextCall(closure0);"
         "%DebugPrint(closure0());");
-    Handle<JSFunction> fun0 = v8::Utils::OpenHandle(
-        *v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("closure0"))));
+    Handle<JSFunction> fun0 = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            env->Global()->Get(v8_str("closure0")))));
     CHECK(fun0->IsOptimized() || !CcTest::i_isolate()->use_crankshaft());
     reference_code = handle(fun0->code());
     // Evict only the context-dependent entry from the optimized code map. This
     // leaves it in a state where only the context-independent entry exists.
     fun0->shared()->TrimOptimizedCodeMap(SharedFunctionInfo::kEntryLength);
   }
   for (int i = 0; i < 3; i++) {
     LocalContext env;
     env->Global()->Set(v8::String::NewFromUtf8(CcTest::isolate(), "x"),
                        v8::Integer::New(CcTest::isolate(), i));
     script->GetUnboundScript()->BindToCurrentContext()->Run();
     CompileRun(
         "var closure0 = MakeClosure();"
         "%DebugPrint(closure0());"
         "%OptimizeFunctionOnNextCall(closure0);"
         "%DebugPrint(closure0());"
         "var closure1 = MakeClosure();"
         "var closure2 = MakeClosure();");
-    Handle<JSFunction> fun1 = v8::Utils::OpenHandle(
-        *v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("closure1"))));
-    Handle<JSFunction> fun2 = v8::Utils::OpenHandle(
-        *v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("closure2"))));
+    Handle<JSFunction> fun1 = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            env->Global()->Get(v8_str("closure1")))));
+    Handle<JSFunction> fun2 = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            env->Global()->Get(v8_str("closure2")))));
     CHECK(fun1->IsOptimized() || !CcTest::i_isolate()->use_crankshaft());
     CHECK(fun2->IsOptimized() || !CcTest::i_isolate()->use_crankshaft());
     CHECK_EQ(*reference_code, fun1->code());
     CHECK_EQ(*reference_code, fun2->code());
   }
 }
 
 
 TEST(CompileFunctionInContext) {
   CcTest::InitializeVM();
@@ skipping 126 matching lines @@
   CHECK(!stack.IsEmpty());
   CHECK(stack->GetFrameCount() > 0);
   v8::Local<v8::StackFrame> frame = stack->GetFrame(0);
   CHECK_EQ(23, frame->GetLineNumber());
   CHECK_EQ(42 + strlen("throw "), static_cast<unsigned>(frame->GetColumn()));
 }
 
 
 #ifdef ENABLE_DISASSEMBLER
 static Handle<JSFunction> GetJSFunction(v8::Handle<v8::Object> obj,
-                                 const char* property_name) {
+                                        const char* property_name) {
   v8::Local<v8::Function> fun =
       v8::Local<v8::Function>::Cast(obj->Get(v8_str(property_name)));
-  return v8::Utils::OpenHandle(*fun);
+  return Handle<JSFunction>::cast(v8::Utils::OpenHandle(*fun));
 }
 
 
 static void CheckCodeForUnsafeLiteral(Handle<JSFunction> f) {
   // Create a disassembler with default name lookup.
   disasm::NameConverter name_converter;
   disasm::Disassembler d(name_converter);
 
   if (f->code()->kind() == Code::FUNCTION) {
     Address pc = f->code()->instruction_start();
@@ skipping 29 matching lines @@
   CompileRun("function f() { a = 12345678 }; f();");
   CheckCodeForUnsafeLiteral(GetJSFunction(context->Global(), "f"));
   CompileRun("function f(x) { a = 12345678 + x}; f(1);");
   CheckCodeForUnsafeLiteral(GetJSFunction(context->Global(), "f"));
   CompileRun("function f(x) { var arguments = 1; x += 12345678}; f(1);");
   CheckCodeForUnsafeLiteral(GetJSFunction(context->Global(), "f"));
   CompileRun("function f(x) { var arguments = 1; x = 12345678}; f(1);");
   CheckCodeForUnsafeLiteral(GetJSFunction(context->Global(), "f"));
 }
 #endif