FYI Implementing 'super' keyword

src/heap/heap.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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/once.h"
 #include "src/base/utils/random-number-generator.h"
@@ skipping 3571 matching lines @@
   HeapObject* obj;
   DCHECK(!allocation.To(&obj) || !obj->IsGlobalObject());
 #endif
   return allocation;
 }
 
 
 AllocationResult Heap::CopyJSObject(JSObject* source, AllocationSite* site) {
   // Never used to copy functions.  If functions need to be copied we
   // have to be careful to clear the literals array.
-  SLOW_DCHECK(!source->IsJSFunction());
+  // SLOW_DCHECK(!source->IsJSFunction());
 
   // Make the clone.
   Map* map = source->map();
   int object_size = map->instance_size();
   HeapObject* clone;
 
   DCHECK(site == NULL || AllocationSite::CanTrack(map->instance_type()));
 
   WriteBarrierMode wb_mode = UPDATE_WRITE_BARRIER;
 
@@ skipping 54 matching lines @@
   }
   // Update properties if necessary.
   if (properties->length() > 0) {
     FixedArray* prop;
     {
       AllocationResult allocation = CopyFixedArray(properties);
       if (!allocation.To(&prop)) return allocation;
     }
     JSObject::cast(clone)->set_properties(prop, wb_mode);
   }
+
+  if (source->IsJSFunction()) {
+    SLOW_DCHECK(clone->IsJSFunction());
+    JSFunction* source_fun = JSFunction::cast(source);
+    JSFunction* clone_fun = JSFunction::cast(clone);
+    SharedFunctionInfo* info = source_fun->shared();
+    if (!info->bound()) {
+      int num_literals = info->num_literals();
+      HeapObject* obj;
+      {
+        AllocationResult allocation = AllocateFixedArrayWithFiller(
+            num_literals, NOT_TENURED, undefined_value());
+        if (!allocation.To(&obj)) return allocation;
+      }
+      FixedArray* new_literals = FixedArray::cast(obj);
+      if (num_literals > 0) {
+        new_literals->set(JSFunction::kLiteralNativeContextIndex,
+            JSFunction::NativeContextFromLiterals(source_fun->literals()));
+      }
+      clone_fun->set_literals(new_literals);
+    }
+  }
   // Return the new clone.
   return clone;
 }
 
 
 static inline void WriteOneByteData(Vector<const char> vector, uint8_t* chars,
                                     int len) {
   // Only works for ascii.
   DCHECK(vector.length() == len);
   MemCopy(chars, vector.start(), len);
@@ skipping 2374 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 }
 }  // namespace v8::internal