Add more debugging information to scripts compiled through eval

src/bootstrapper.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 29 matching lines @@
 namespace v8 {
 namespace internal {
 
 // A SourceCodeCache uses a FixedArray to store pairs of
 // (AsciiString*, JSFunction*), mapping names of native code files
 // (runtime.js, etc.) to precompiled functions. Instead of mapping
 // names to functions it might make sense to let the JS2C tool
 // generate an index for each native JS file.
 class SourceCodeCache BASE_EMBEDDED {
  public:
-  explicit SourceCodeCache(ScriptType type): type_(type) { }
+  explicit SourceCodeCache(Script::Type type): type_(type) { }
 
   void Initialize(bool create_heap_objects) {
     if (create_heap_objects) {
       cache_ = Heap::empty_fixed_array();
     } else {
       cache_ = NULL;
     }
   }
 
   void Iterate(ObjectVisitor* v) {
@@ skipping 21 matching lines @@
         Factory::NewFixedArray(length + 2, TENURED);
     cache_->CopyTo(0, *new_array, 0, cache_->length());
     cache_ = *new_array;
     Handle<String> str = Factory::NewStringFromAscii(name, TENURED);
     cache_->set(length, *str);
     cache_->set(length + 1, *fun);
     Script::cast(fun->shared()->script())->set_type(Smi::FromInt(type_));
   }
 
  private:
-  ScriptType type_;
+  Script::Type type_;
   FixedArray* cache_;
   DISALLOW_COPY_AND_ASSIGN(SourceCodeCache);
 };
 
-static SourceCodeCache natives_cache(SCRIPT_TYPE_NATIVE);
-static SourceCodeCache extensions_cache(SCRIPT_TYPE_EXTENSION);
+static SourceCodeCache natives_cache(Script::TYPE_NATIVE);
+static SourceCodeCache extensions_cache(Script::TYPE_EXTENSION);
 
 
 Handle<String> Bootstrapper::NativesSourceLookup(int index) {
   ASSERT(0 <= index && index < Natives::GetBuiltinsCount());
   if (Heap::natives_source_cache()->get(index)->IsUndefined()) {
     Handle<String> source_code =
       Factory::NewStringFromAscii(Natives::GetScriptSource(index));
     Heap::natives_source_cache()->set(index, *source_code);
   }
   Handle<Object> cached_source(Heap::natives_source_cache()->get(index));
@@ skipping 406 matching lines @@
   Handle<String> symbol = Factory::LookupAsciiSymbol("Empty");
   Handle<JSFunction> empty_function =
       Factory::NewFunction(symbol, Factory::null_value());
 
   {  // --- E m p t y ---
     Handle<Code> code =
         Handle<Code>(Builtins::builtin(Builtins::EmptyFunction));
     empty_function->set_code(*code);
     Handle<String> source = Factory::NewStringFromAscii(CStrVector("() {}"));
     Handle<Script> script = Factory::NewScript(source);
-    script->set_type(Smi::FromInt(SCRIPT_TYPE_NATIVE));
+    script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
     empty_function->shared()->set_script(*script);
     empty_function->shared()->set_start_position(0);
     empty_function->shared()->set_end_position(source->length());
     empty_function->shared()->DontAdaptArguments();
     global_context()->function_map()->set_prototype(*empty_function);
     global_context()->function_instance_map()->set_prototype(*empty_function);
 
     // Allocate the function map first and then patch the prototype later
     Handle<Map> empty_fm = Factory::CopyMapDropDescriptors(fm);
     empty_fm->set_instance_descriptors(*function_map_descriptors);
@@ skipping 519 matching lines @@
             Factory::LookupAsciiSymbol("data"),
             proxy_data,
             common_attributes);
     Handle<Proxy> proxy_type = Factory::NewProxy(&Accessors::ScriptType);
     script_descriptors =
         Factory::CopyAppendProxyDescriptor(
             script_descriptors,
             Factory::LookupAsciiSymbol("type"),
             proxy_type,
             common_attributes);
+    Handle<Proxy> proxy_compilation_type =
+        Factory::NewProxy(&Accessors::ScriptCompilationType);
+    script_descriptors =
+        Factory::CopyAppendProxyDescriptor(
+            script_descriptors,
+            Factory::LookupAsciiSymbol("compilation_type"),
+            proxy_compilation_type,
+            common_attributes);
     Handle<Proxy> proxy_line_ends =
         Factory::NewProxy(&Accessors::ScriptLineEnds);
     script_descriptors =
         Factory::CopyAppendProxyDescriptor(
             script_descriptors,
             Factory::LookupAsciiSymbol("line_ends"),
             proxy_line_ends,
             common_attributes);
     Handle<Proxy> proxy_context_data =
         Factory::NewProxy(&Accessors::ScriptContextData);
     script_descriptors =
         Factory::CopyAppendProxyDescriptor(
             script_descriptors,
             Factory::LookupAsciiSymbol("context_data"),
             proxy_context_data,
             common_attributes);
+    Handle<Proxy> proxy_eval_from_function =
+        Factory::NewProxy(&Accessors::ScriptEvalFromFunction);
+    script_descriptors =
+        Factory::CopyAppendProxyDescriptor(
+            script_descriptors,
+            Factory::LookupAsciiSymbol("eval_from_function"),
+            proxy_eval_from_function,
+            common_attributes);
+    Handle<Proxy> proxy_eval_from_position =
+        Factory::NewProxy(&Accessors::ScriptEvalFromPosition);
+    script_descriptors =
+        Factory::CopyAppendProxyDescriptor(
+            script_descriptors,
+            Factory::LookupAsciiSymbol("eval_from_position"),
+            proxy_eval_from_position,
+            common_attributes);
 
     Handle<Map> script_map = Handle<Map>(script_fun->initial_map());
     script_map->set_instance_descriptors(*script_descriptors);
 
     // Allocate the empty script.
     Handle<Script> script = Factory::NewScript(Factory::empty_string());
-    script->set_type(Smi::FromInt(SCRIPT_TYPE_NATIVE));
+    script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
     global_context()->set_empty_script(*script);
   }
 
 #ifdef V8_HOST_ARCH_64_BIT
   // TODO(X64): Reenable remaining initialization when code generation works.
   return true;
 #endif  // V8_HOST_ARCH_64_BIT
 
 
   if (FLAG_natives_file == NULL) {
@@ skipping 491 matching lines @@
 }
 
 
 // Restore statics that are thread local.
 char* Genesis::RestoreState(char* from) {
   current_ = *reinterpret_cast<Genesis**>(from);
   return from + sizeof(current_);
 }
 
 } }  // namespace v8::internal