Fix second half of issue 1151, the first change (r6765) only fixed FunctionGe...

src/accessors.cc

 // Copyright 2006-2008 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 429 matching lines @@
 //
 // Accessors::FunctionPrototype
 //
 
 
 MaybeObject* Accessors::FunctionGetPrototype(Object* object, void*) {
   bool found_it = false;
   JSFunction* function = FindInPrototypeChain<JSFunction>(object, &found_it);
   if (!found_it) return Heap::undefined_value();
   if (!function->has_prototype()) {
-    if (!function->should_have_prototype()) return Heap::undefined_value();
+    if (!function->should_have_prototype()) {

[Mads Ager (chromium), 2011/02/22 10:17:07]

Can we simplify this? How about moving this before the
!function->has_prototype() check and doing something like:

while (!function->should_have_prototype()) {
  found_it = false;
  function = FindInPrototypeChain<JSFunction>(object->GetPrototype(),
&found_it);
  ASSERT(found_it);  // There has to be one because we hit the getter
}

That should be all that we need. Then the original code will do the right thing
as far as I can tell?

[Rico, 2011/02/22 12:22:44]

Done.

+      // Check if there is a 'prototype' property.
+      LookupResult result;
+      Handle<String> proto_name =

[Mads Ager (chromium), 2011/02/22 10:17:07]

This code does not use handles. You can use Heap::prototype_symbol() below
instead. 

[Rico, 2011/02/22 12:22:44]

Done.

+          Factory::NewStringFromAscii(CStrVector("prototype"));
+      function->Lookup(*proto_name, &result);
+
+      if (result.IsProperty()) {
+        if (result.holder()->IsJSFunction()) {
+          JSFunction* jsfunction = JSFunction::cast(result.holder());
+          if (jsfunction->has_prototype()) return jsfunction->prototype();
+        }
+      }
+      // There was no prototype in the prototype chain, return undefined.
+      return Heap::undefined_value();
+    }
     Object* prototype;
     { MaybeObject* maybe_prototype = Heap::AllocateFunctionPrototype(function);
       if (!maybe_prototype->ToObject(&prototype)) return maybe_prototype;
     }
     Object* result;
     { MaybeObject* maybe_result = function->SetPrototype(prototype);
       if (!maybe_result->ToObject(&result)) return maybe_result;
     }
   }
   return function->prototype();
 }
 
 
 MaybeObject* Accessors::FunctionSetPrototype(JSObject* object,
                                              Object* value,
                                              void*) {
   bool found_it = false;
   JSFunction* function = FindInPrototypeChain<JSFunction>(object, &found_it);
   if (!found_it) return Heap::undefined_value();
+  if (!function->should_have_prototype()) {
+    return object->SetLocalPropertyIgnoreAttributes(

[Mads Ager (chromium), 2011/02/22 10:17:07]

Please add a comment stating that object does not have a prototype property
since we hit this accessor.

[Rico, 2011/02/22 12:22:44]

Done.

+        *Factory::NewStringFromAscii(CStrVector("prototype")),

[Mads Ager (chromium), 2011/02/22 10:17:07]

Heap::prototype_symbol()

[Rico, 2011/02/22 12:22:44]

Done.

+        value,
+        NONE);
+  }
+
   if (function->has_initial_map()) {
     // If the function has allocated the initial map
     // replace it with a copy containing the new prototype.
     Object* new_map;
     { MaybeObject* maybe_new_map =
           function->initial_map()->CopyDropTransitions();
       if (!maybe_new_map->ToObject(&new_map)) return maybe_new_map;
     }
     function->set_initial_map(Map::cast(new_map));
   }
@@ skipping 404 matching lines @@
 }
 
 
 const AccessorDescriptor Accessors::ObjectPrototype = {
   ObjectGetPrototype,
   ObjectSetPrototype,
   0
 };
 
 } }  // namespace v8::internal