Merge revision 3813 to 3930 from bleeding_edge to partial snapshots branch.

src/compiler.cc

 // Copyright 2009 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 20 matching lines @@
 #include "codegen-inl.h"
 #include "compilation-cache.h"
 #include "compiler.h"
 #include "debug.h"
 #include "fast-codegen.h"
 #include "full-codegen.h"
 #include "oprofile-agent.h"
 #include "rewriter.h"
 #include "scopes.h"
 #include "usage-analyzer.h"
+#include "liveedit.h"
 
 namespace v8 {
 namespace internal {
 
 
 static Handle<Code> MakeCode(Handle<Context> context, CompilationInfo* info) {
   FunctionLiteral* function = info->function();
   ASSERT(function != NULL);
   // Rewrite the AST by introducing .result assignments where needed.
   if (!Rewriter::Process(function) || !AnalyzeVariableUsage(function)) {
@@ skipping 180 matching lines @@
 
 
 static StaticResource<SafeStringInputBuffer> safe_string_input_buffer;
 
 
 Handle<JSFunction> Compiler::Compile(Handle<String> source,
                                      Handle<Object> script_name,
                                      int line_offset, int column_offset,
                                      v8::Extension* extension,
                                      ScriptDataImpl* input_pre_data,
+                                     Handle<Object> script_data,
                                      NativesFlag natives) {
   int source_length = source->length();
   Counters::total_load_size.Increment(source_length);
   Counters::total_compile_size.Increment(source_length);
 
   // The VM is in the COMPILER state until exiting this function.
   VMState state(COMPILER);
 
   // Do a lookup in the compilation cache but not for extensions.
   Handle<JSFunction> result;
@@ skipping 17 matching lines @@
     Handle<Script> script = Factory::NewScript(source);
     if (natives == NATIVES_CODE) {
       script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
     }
     if (!script_name.is_null()) {
       script->set_name(*script_name);
       script->set_line_offset(Smi::FromInt(line_offset));
       script->set_column_offset(Smi::FromInt(column_offset));
     }
 
+    script->set_data(script_data.is_null() ? Heap::undefined_value()
+                                           : *script_data);
+
     // Compile the function and add it to the cache.
     result = MakeFunction(true,
                           false,
                           DONT_VALIDATE_JSON,
                           script,
                           Handle<Context>::null(),
                           extension,
                           pre_data);
     if (extension == NULL && !result.is_null()) {
       CompilationCache::PutScript(source, result);
@@ skipping 134 matching lines @@
   // We should not try to compile the same function literal more than
   // once.
   literal->mark_as_compiled();
 #endif
 
   // Determine if the function can be lazily compiled. This is
   // necessary to allow some of our builtin JS files to be lazily
   // compiled. These builtins cannot be handled lazily by the parser,
   // since we have to know if a function uses the special natives
   // syntax, which is something the parser records.
-  bool allow_lazy = literal->AllowsLazyCompilation();
+  bool allow_lazy = literal->AllowsLazyCompilation() &&
+      !LiveEditFunctionTracker::IsActive();
 
   // Generate code
   Handle<Code> code;
   if (FLAG_lazy && allow_lazy) {
     code = ComputeLazyCompile(literal->num_parameters());
   } else {
     // The bodies of function literals have not yet been visited by
     // the AST optimizer/analyzer.
     if (!Rewriter::Optimize(literal)) {
       return Handle<JSFunction>::null();
@@ skipping 118 matching lines @@
       LOG(CodeCreateEvent(tag, *code, *func_name));
       OProfileAgent::CreateNativeCodeRegion(*func_name,
                                             code->instruction_start(),
                                             code->instruction_size());
     }
   }
 }
 #endif
 
 } }  // namespace v8::internal