[Interpreter] Add support for Load / Store to Lookup slots.

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 3033 matching lines @@
     InterpreterTester tester(handles.main_isolate(), samples[i].first);
     auto callable = tester.GetCallable<Handle<Object>>();
     Handle<Object> return_val =
         callable(handle(Smi::FromInt(arg_value), handles.main_isolate()))
             .ToHandleChecked();
     CHECK_EQ(Handle<Smi>::cast(return_val)->value(), samples[i].second);
   }
 }
 
 
-TEST(InterpreterEval) {
+TEST(InterpreterEvalLocal) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
 
   std::pair<const char*, Handle<Object>> eval[] = {
       std::make_pair("return eval('1;');", handle(Smi::FromInt(1), isolate)),
       std::make_pair("return eval('100 * 20;');",
                      handle(Smi::FromInt(2000), isolate)),
-      // TODO(mythria): Add more tests here where eval uses / modifies variables
-      // and parameters from the function's scope when we have support for
-      // lookup variables.
+      std::make_pair("var x = 10; return eval('x + 20;');",
+                     handle(Smi::FromInt(30), isolate)),
+      std::make_pair("var x = 10; eval('x = 33;'); return x;",
+                     handle(Smi::FromInt(33), isolate)),
+      std::make_pair("'use strict'; var x = 20; var z = 0; eval('var x = 33; z "
+                     "= x;'); return x + z;",
+                     handle(Smi::FromInt(53), isolate)),
+      std::make_pair(
+          "eval('var x = 33;'); eval('var y = x + 20'); return x + y;",
+          handle(Smi::FromInt(86), isolate)),
   };
 
   for (size_t i = 0; i < arraysize(eval); i++) {
+    std::string source(InterpreterTester::SourceForBody(eval[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(*eval[i].second));
+  }
+}
+
+
+TEST(InterpreterEvalParams) {
+  HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+
+  std::pair<const char*, Handle<Object>> eval_params[] = {
+      std::make_pair("var x = 10; return eval('x + p1;');",
+                     handle(Smi::FromInt(30), isolate)),
+      std::make_pair("var x = 10; eval('p1 = x;'); return p1;",
+                     handle(Smi::FromInt(10), isolate)),
+      std::make_pair("var a = 10;"
+                     "function inner() { return eval('a + p1;');}"
+                     "return inner();",
+                     handle(Smi::FromInt(30), isolate)),
+  };
+
+  for (size_t i = 0; i < arraysize(eval_params); i++) {
+    std::string source = "function " + InterpreterTester::function_name() +
+                         "(p1) {" + eval_params[i].first + "}";
+    InterpreterTester tester(handles.main_isolate(), source.c_str());
+    auto callable = tester.GetCallable<Handle<Object>>();
+
+    Handle<i::Object> return_value =
+        callable(handle(Smi::FromInt(20), isolate)).ToHandleChecked();
+    CHECK(return_value->SameValue(*eval_params[i].second));
+  }
+}
+
+
+TEST(InterpreterEvalGlobal) {
+  HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+
+  std::pair<const char*, Handle<Object>> eval_global[] = {
+      std::make_pair("function add_global() { eval('x = 33;'); }; "
+                     "function f() { add_global(); return x; }"
+                     "f();",
+                     handle(Smi::FromInt(33), isolate)),
+      std::make_pair(
+          "function add_global() { 'use strict'; eval('x = 33;'); }; "
+          "function f() { add_global(); return x; }"
+          "f();",
+          handle(Smi::FromInt(33), isolate)),
+  };
+
+  for (size_t i = 0; i < arraysize(eval_global); i++) {
+    InterpreterTester tester(handles.main_isolate(), eval_global[i].first, "*");
+    auto callable = tester.GetCallable<>();
+
+    Handle<i::Object> return_value = callable().ToHandleChecked();
+    CHECK(return_value->SameValue(*eval_global[i].second));
+  }
+}
+
+
+TEST(InterpreterEval) {
+  HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+  i::Factory* factory = isolate->factory();
+
+  const char* func =
+      "var x = 42;"
+      "function f(str, p1) {"
+      "  if(p1) { eval(str) }"
+      "  x = x + 10;"
+      " return x;"
+      "}"
+      "f('var x = 10', 1);";
+
+  Handle<Object> params[][3] = {
+      {factory->NewNumberFromInt(30),
+       factory->NewStringFromStaticChars("var x = 20;"), factory->true_value()},
+      {factory->NewNumberFromInt(52),
+       factory->NewStringFromStaticChars("var x = 20;"),
+       factory->false_value()},
+      {factory->NewNumberFromInt(52),
+       factory->NewStringFromStaticChars("'use strict'; var x = 20;"),
+       factory->true_value()},
+      {factory->NewNumberFromInt(52),
+       factory->NewStringFromStaticChars("'use strict'; var x = 20;"),
+       factory->false_value()},
+      {factory->NewNumberFromInt(62),
+       factory->NewStringFromStaticChars("for(i = 0; i < 10; i++) x = x + 1;"),
+       factory->true_value()},
+  };
+
+  for (size_t i = 0; i < arraysize(params); i++) {
+    InterpreterTester tester(handles.main_isolate(), func);
+    auto callable = tester.GetCallable<Handle<Object>, Handle<Object>>();
+    Handle<i::Object> return_value =
+        callable(params[i][1], params[i][2]).ToHandleChecked();
+    CHECK(return_value->SameValue(*params[i][0]));
+  }
+}
+
+
+TEST(InterpreterEvalInsideTypeOf) {
+  HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+  i::Factory* factory = isolate->factory();
+
+  std::pair<const char*, Handle<Object>> eval[] = {
+      std::make_pair("var x = 10; eval('x + 20;'); return typeof x;",
+                     factory->NewStringFromStaticChars("number")),
+      std::make_pair("eval('var y = 10;');"
+                     "return typeof x;",
+                     factory->NewStringFromStaticChars("undefined")),
+      std::make_pair("'use strict';"
+                     "eval('var y = 10;');"
+                     "return typeof x;",
+                     factory->NewStringFromStaticChars("undefined")),
+      std::make_pair("eval('var x = 10;'); return typeof x;",
+                     factory->NewStringFromStaticChars("number")),
+      std::make_pair("var x = {};"
+                     "eval('var x = 10;');"
+                     "return typeof x;",
+                     factory->NewStringFromStaticChars("number")),
+      std::make_pair("'use strict';"
+                     "var x = {};"
+                     "eval('var x = 10;');"
+                     "return typeof x;",
+                     factory->NewStringFromStaticChars("object")),
+  };
+
+  for (size_t i = 0; i < arraysize(eval); i++) {
     std::string source(InterpreterTester::SourceForBody(eval[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(*eval[i].second));
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8