Load closure from activation for building literals.

test/cctest/compiler/function-tester.h

Index: test/cctest/compiler/function-tester.h
diff --git a/test/cctest/compiler/function-tester.h b/test/cctest/compiler/function-tester.h
index 67b704db911d30add319c8a670f6ed4f05607d19..1e16d4fa5ec28369d6d966b8b782e448cc6a37cf 100644
--- a/test/cctest/compiler/function-tester.h
+++ b/test/cctest/compiler/function-tester.h
@@ -26,9 +26,11 @@ namespace compiler {
 
 class FunctionTester : public InitializedHandleScope {
  public:
-  explicit FunctionTester(const char* source)
+  explicit FunctionTester(const char* source, bool context_specialization =
+                                                  FLAG_context_specialization)
       : isolate(main_isolate()),
-        function((FLAG_allow_natives_syntax = true, NewFunction(source))) {
+        function((FLAG_allow_natives_syntax = true, NewFunction(source))),
+        context_specialization_(context_specialization) {
     Compile(function);
   }
 
@@ -51,7 +53,7 @@ class FunctionTester : public InitializedHandleScope {
 
     EnsureDeoptimizationSupport(&info);
 
-    Pipeline pipeline(&info);
+    Pipeline pipeline(&info, context_specialization_);
     Handle<Code> code = pipeline.GenerateCode();
 
     CHECK(!code.is_null());
@@ -188,6 +190,27 @@ class FunctionTester : public InitializedHandleScope {
   Handle<Object> true_value() { return isolate->factory()->true_value(); }
 
   Handle<Object> false_value() { return isolate->factory()->false_value(); }
+
+  template <typename Lambda>
+  void RunInSeparateContext(const char* script, Lambda body) {
+    v8::Local<v8::Context> env = v8::Context::New(CcTest::isolate());
+    v8::Context::Scope scope(env);
+    v8::Local<v8::Value> val = CompileRun(script);
+    body(env, val);
+  }
+
+  template <typename Lambda>
+  void CompileFunctionInSeparateContext(const char* script, Lambda body) {
+    RunInSeparateContext(script, [&body](v8::Handle<v8::Context> context,
+                                         v8::Handle<Value> value) {
+      i::Handle<i::Object> ofun = v8::Utils::OpenHandle(*value);
+      i::Handle<i::JSFunction> jsfun = Handle<JSFunction>::cast(ofun);
+      body(context, jsfun);
+    });
+  }
+
+ private:
+  bool context_specialization_;
 };
 }
 }