Implement new Function.prototype.toString and fix CreateDynamicFunction parsing

src/compilation-cache.cc

 // Copyright 2011 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/compilation-cache.h"
 
 #include "src/counters.h"
 #include "src/factory.h"
 #include "src/globals.h"
 #include "src/objects-inl.h"
@@ skipping 176 matching lines @@
                                  Handle<SharedFunctionInfo> function_info,
                                  Handle<Cell> literals) {
   HandleScope scope(isolate());
   Handle<CompilationCacheTable> table = GetFirstTable();
   SetFirstTable(CompilationCacheTable::PutScript(
       table, source, context, language_mode, function_info, literals));
 }
 
 InfoVectorPair CompilationCacheEval::Lookup(
     Handle<String> source, Handle<SharedFunctionInfo> outer_info,
-    Handle<Context> native_context, LanguageMode language_mode,
-    int scope_position) {
+    Handle<Context> native_context, LanguageMode language_mode, int position) {
   HandleScope scope(isolate());
   // Make sure not to leak the table into the surrounding handle
   // scope. Otherwise, we risk keeping old tables around even after
   // having cleared the cache.
   InfoVectorPair result;
   const int generation = 0;
   DCHECK(generations() == 1);
   Handle<CompilationCacheTable> table = GetTable(generation);
   result = table->LookupEval(source, outer_info, native_context, language_mode,
-                             scope_position);
+                             position);
   if (result.has_shared()) {
     isolate()->counters()->compilation_cache_hits()->Increment();
   } else {
     isolate()->counters()->compilation_cache_misses()->Increment();
   }
   return result;
 }
 
 void CompilationCacheEval::Put(Handle<String> source,
                                Handle<SharedFunctionInfo> outer_info,
                                Handle<SharedFunctionInfo> function_info,
                                Handle<Context> native_context,
-                               Handle<Cell> literals, int scope_position) {
+                               Handle<Cell> literals, int position) {
   HandleScope scope(isolate());
   Handle<CompilationCacheTable> table = GetFirstTable();
   table =
       CompilationCacheTable::PutEval(table, source, outer_info, function_info,
-                                     native_context, literals, scope_position);
+                                     native_context, literals, position);
   SetFirstTable(table);
 }
 
 
 MaybeHandle<FixedArray> CompilationCacheRegExp::Lookup(
     Handle<String> source,
     JSRegExp::Flags flags) {
   HandleScope scope(isolate());
   // Make sure not to leak the table into the surrounding handle
   // scope. Otherwise, we risk keeping old tables around even after
@@ skipping 42 matching lines @@
     Handle<Context> context, LanguageMode language_mode) {
   InfoVectorPair empty_result;
   if (!IsEnabled()) return empty_result;
 
   return script_.Lookup(source, name, line_offset, column_offset,
                         resource_options, context, language_mode);
 }
 
 InfoVectorPair CompilationCache::LookupEval(
     Handle<String> source, Handle<SharedFunctionInfo> outer_info,
-    Handle<Context> context, LanguageMode language_mode, int scope_position) {
+    Handle<Context> context, LanguageMode language_mode, int position) {
   InfoVectorPair result;
   if (!IsEnabled()) return result;
 
   if (context->IsNativeContext()) {
     result = eval_global_.Lookup(source, outer_info, context, language_mode,
-                                 scope_position);
+                                 position);
   } else {
-    DCHECK(scope_position != kNoSourcePosition);
+    DCHECK(position != kNoSourcePosition);
     Handle<Context> native_context(context->native_context(), isolate());
     result = eval_contextual_.Lookup(source, outer_info, native_context,
-                                     language_mode, scope_position);
+                                     language_mode, position);
   }
 
   return result;
 }
 
 
 MaybeHandle<FixedArray> CompilationCache::LookupRegExp(Handle<String> source,
                                                        JSRegExp::Flags flags) {
   if (!IsEnabled()) return MaybeHandle<FixedArray>();
 
   return reg_exp_.Lookup(source, flags);
 }
 
 void CompilationCache::PutScript(Handle<String> source, Handle<Context> context,
                                  LanguageMode language_mode,
                                  Handle<SharedFunctionInfo> function_info,
                                  Handle<Cell> literals) {
   if (!IsEnabled()) return;
 
   script_.Put(source, context, language_mode, function_info, literals);
 }
 
 void CompilationCache::PutEval(Handle<String> source,
                                Handle<SharedFunctionInfo> outer_info,
                                Handle<Context> context,
                                Handle<SharedFunctionInfo> function_info,
-                               Handle<Cell> literals, int scope_position) {
+                               Handle<Cell> literals, int position) {
   if (!IsEnabled()) return;
 
   HandleScope scope(isolate());
   if (context->IsNativeContext()) {
     eval_global_.Put(source, outer_info, function_info, context, literals,
-                     scope_position);
+                     position);
   } else {
-    DCHECK(scope_position != kNoSourcePosition);
+    DCHECK(position != kNoSourcePosition);
     Handle<Context> native_context(context->native_context(), isolate());
     eval_contextual_.Put(source, outer_info, function_info, native_context,
-                         literals, scope_position);
+                         literals, position);
   }
 }
 
 
 
 void CompilationCache::PutRegExp(Handle<String> source,
                                  JSRegExp::Flags flags,
                                  Handle<FixedArray> data) {
   if (!IsEnabled()) {
     return;
@@ skipping 37 matching lines @@
 
 
 void CompilationCache::Disable() {
   enabled_ = false;
   Clear();
 }
 
 
 }  // namespace internal
 }  // namespace v8