[Interpreter] Add support for loading from / storing to outer context variables.

test/cctest/interpreter/test-interpreter.cc

 // Copyright 2015 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/execution.h"
 #include "src/handles.h"
 #include "src/interpreter/bytecode-array-builder.h"
 #include "src/interpreter/interpreter.h"
@@ skipping 40 matching lines @@
 };
 
 
 static const char* kFunctionName = "f";
 
 
 class InterpreterTester {
  public:
   InterpreterTester(Isolate* isolate, const char* source,
                     MaybeHandle<BytecodeArray> bytecode,
-                    MaybeHandle<TypeFeedbackVector> feedback_vector)
+                    MaybeHandle<TypeFeedbackVector> feedback_vector,
+                    const char* filter)
       : isolate_(isolate),
         source_(source),
         bytecode_(bytecode),
         feedback_vector_(feedback_vector) {
     i::FLAG_vector_stores = true;
     i::FLAG_ignition = true;
     i::FLAG_ignition_fake_try_catch = true;
     i::FLAG_always_opt = false;
     // Set ignition filter flag via SetFlagsFromString to avoid double-free
     // (or potential leak with StrDup() based on ownership confusion).
     ScopedVector<char> ignition_filter(64);
-    SNPrintF(ignition_filter, "--ignition-filter=%s", kFunctionName);
+    SNPrintF(ignition_filter, "--ignition-filter=%s", filter);
     FlagList::SetFlagsFromString(ignition_filter.start(),
                                  ignition_filter.length());
     // Ensure handler table is generated.
     isolate->interpreter()->Initialize();
   }
 
   InterpreterTester(Isolate* isolate, Handle<BytecodeArray> bytecode,
                     MaybeHandle<TypeFeedbackVector> feedback_vector =
-                        MaybeHandle<TypeFeedbackVector>())
-      : InterpreterTester(isolate, nullptr, bytecode, feedback_vector) {}
+                        MaybeHandle<TypeFeedbackVector>(),
+                    const char* filter = kFunctionName)
+      : InterpreterTester(isolate, nullptr, bytecode, feedback_vector, filter) {
+  }
 
 
-  InterpreterTester(Isolate* isolate, const char* source)
+  InterpreterTester(Isolate* isolate, const char* source,
+                    const char* filter = kFunctionName)
       : InterpreterTester(isolate, source, MaybeHandle<BytecodeArray>(),
-                          MaybeHandle<TypeFeedbackVector>()) {}
+                          MaybeHandle<TypeFeedbackVector>(), filter) {}
 
   virtual ~InterpreterTester() {}
 
   template <class... A>
   InterpreterCallable<A...> GetCallable() {
     return InterpreterCallable<A...>(isolate_, GetBytecodeFunction<A...>());
   }
 
   static Handle<Object> NewObject(const char* script) {
     return v8::Utils::OpenHandle(*CompileRun(script));
@@ skipping 1813 matching lines @@
 
     Handle<Object> a1 = handle(Smi::FromInt(1), isolate);
     Handle<Object> a2 = handle(Smi::FromInt(2), isolate);
     Handle<Object> a3 = handle(Smi::FromInt(3), isolate);
     Handle<i::Object> return_value = callable(a1, a2, a3).ToHandleChecked();
     CHECK(return_value->SameValue(*context_params[i].second));
   }
 }
 
 
+TEST(InterpreterOuterContextVariables) {
+  HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+
+  std::pair<const char*, Handle<Object>> context_vars[2] = {
+      std::make_pair("return outerVar * innerArg;",
+                     handle(Smi::FromInt(200), isolate)),
+      std::make_pair("outerVar = innerArg; return outerVar",
+                     handle(Smi::FromInt(20), isolate)),
+  };
+
+  std::string header(
+      "function Outer() {"
+      "  var outerVar = 10;"
+      "  function Inner(innerArg) {"
+      "    this.innerFunc = function() { ");
+  std::string footer(
+      "  }}"
+      "  this.getInnerFunc = function() { return new Inner(20).innerFunc; }"
+      "}"
+      "var f = new Outer().getInnerFunc();");
+
+  for (size_t i = 0; i < arraysize(context_vars); i++) {
+    std::string source = header + context_vars[i].first + footer;
+    InterpreterTester tester(handles.main_isolate(), source.c_str(), "*");
+    auto callable = tester.GetCallable<>();
+
+    Handle<i::Object> return_value = callable().ToHandleChecked();
+    CHECK(return_value->SameValue(*context_vars[i].second));
+  }
+}
+
+
 TEST(InterpreterComma) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
   std::pair<const char*, Handle<Object>> literals[6] = {
       std::make_pair("var a; return 0, a;\n", factory->undefined_value()),
       std::make_pair("return 'a', 2.2, 3;\n",
                      handle(Smi::FromInt(3), isolate)),
       std::make_pair("return 'a', 'b', 'c';\n",
@@ skipping 359 matching lines @@
 
   for (size_t i = 0; i < arraysize(conditional); i++) {
     std::string source(InterpreterTester::SourceForBody(conditional[i].first));
     InterpreterTester tester(handles.main_isolate(), source.c_str());
     auto callable = tester.GetCallable<>();
 
     Handle<i::Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*conditional[i].second));
   }
 }