[proxies] throw TypeError in [[Call]] if is_callable Map bit is unset

src/runtime/runtime.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/runtime/runtime.h"
 
 #include "src/assembler.h"
+#include "src/ast/prettyprinter.h"
 #include "src/contexts.h"
+#include "src/frames-inl.h"
 #include "src/handles-inl.h"
 #include "src/heap/heap.h"
+#include "src/isolate-inl.h"
 #include "src/isolate.h"
+#include "src/parsing/parser.h"
 #include "src/runtime/runtime-utils.h"
 
 namespace v8 {
 namespace internal {
 
 // Header of runtime functions.
 #define F(name, number_of_args, result_size)                    \
   Object* Runtime_##name(int args_length, Object** args_object, \
                          Isolate* isolate);
 FOR_EACH_INTRINSIC_RETURN_OBJECT(F)
@@ skipping 96 matching lines @@
       isolate->runtime_state()->set_redirected_intrinsic_functions(
           redirected_functions);
     }
 
     return isolate->runtime_state()->redirected_intrinsic_functions();
   } else {
     return kIntrinsicFunctions;
   }
 }
 
+bool Runtime::ComputeLocation(Isolate* isolate, MessageLocation* target) {
+  JavaScriptFrameIterator it(isolate);
+  if (!it.done()) {
+    JavaScriptFrame* frame = it.frame();
+    JSFunction* fun = frame->function();
+    Object* script = fun->shared()->script();
+    if (script->IsScript() &&
+        !(Script::cast(script)->source()->IsUndefined())) {
+      Handle<Script> casted_script(Script::cast(script));
+      // Compute the location from the function and the relocation info of the
+      // baseline code. For optimized code this will use the deoptimization
+      // information to get canonical location information.
+      List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
+      it.frame()->Summarize(&frames);
+      FrameSummary& summary = frames.last();
+      int pos = summary.abstract_code()->SourcePosition(summary.code_offset());
+      *target = MessageLocation(casted_script, pos, pos + 1, handle(fun));
+      return true;
+    }
+  }
+  return false;
+}
+
+Handle<String> Runtime::RenderCallSite(Isolate* isolate,
+                                       Handle<Object> object) {
+  MessageLocation location;
+  if (ComputeLocation(isolate, &location)) {
+    Zone zone;
+    base::SmartPointer<ParseInfo> info(
+        location.function()->shared()->is_function()
+            ? new ParseInfo(&zone, location.function())
+            : new ParseInfo(&zone, location.script()));
+    if (Parser::ParseStatic(info.get())) {
+      CallPrinter printer(isolate, location.function()->shared()->IsBuiltin());
+      const char* string = printer.Print(info->literal(), location.start_pos());
+      if (strlen(string) > 0) {
+        return isolate->factory()->NewStringFromAsciiChecked(string);
+      }
+    } else {
+      isolate->clear_pending_exception();
+    }
+  }
+  return Object::TypeOf(isolate, object);
+}
 
 std::ostream& operator<<(std::ostream& os, Runtime::FunctionId id) {
   return os << Runtime::FunctionForId(id)->name;
 }
 
 
 }  // namespace internal
 }  // namespace v8