Fix the debugger for strict-mode functions.

src/runtime.cc

 // Copyright 2011 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 10281 matching lines @@
 
   // Add the value being returned.
   if (at_return) {
     details->set(details_index++, *return_value);
   }
 
   // Add the receiver (same as in function frame).
   // THIS MUST BE DONE LAST SINCE WE MIGHT ADVANCE
   // THE FRAME ITERATOR TO WRAP THE RECEIVER.
   Handle<Object> receiver(it.frame()->receiver(), isolate);
-  if (!receiver->IsJSObject()) {
-    // If the receiver is NOT a JSObject we have hit an optimization
-    // where a value object is not converted into a wrapped JS objects.
-    // To hide this optimization from the debugger, we wrap the receiver
-    // by creating correct wrapper object based on the calling frame's
-    // global context.
+  if (!receiver->IsJSObject() && !receiver->IsUndefined()) {

[Vyacheslav Egorov (Chromium), 2011/07/15 12:43:13]

I think we should check for strict || builtin function instead. Receivers of all
other functions should be wrapped.

I think we have general problem with non-jsobject receivers for strict
functions.

function f() { "use strict"; debugger; }
f.apply("x");

will display this as String object in the debugger while it is actually a
primitive. (But it will not crash).

[Mads Ager (chromium), 2011/07/15 16:32:10]

D'oh! You are absolutely right. Thank you. :-)

That change requires a couple of extra changes as well because the receiver can
now be primitive values as well as undefined and objects.

+    // If the receiver is not a JSObject and is not undefined we have
+    // hit an optimization where a value object is not converted into
+    // a wrapped JS objects. To hide this optimization from the
+    // debugger, we wrap the receiver by creating correct wrapper
+    // object based on the calling frame's global context.
     it.Advance();
     Handle<Context> calling_frames_global_context(
         Context::cast(Context::cast(it.frame()->context())->global_context()));
     receiver =
         isolate->factory()->ToObject(receiver, calling_frames_global_context);
   }
   details->set(kFrameDetailsReceiverIndex, *receiver);
 
   ASSERT_EQ(details_size, details_index);
   return *isolate->factory()->NewJSArrayWithElements(details);
@@ skipping 2351 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(false);
   }
 }
 
 
 } }  // namespace v8::internal