[Interpreter] Add switch support.

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 1700 matching lines @@
       Handle<Smi>(Smi::FromInt(3), handles.main_isolate())).ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(5));
 }
 
 
 TEST(InterpreterRegExpLiterals) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
-  std::pair<const char*, Handle<Object>> literals[5] = {
+  std::pair<const char*, Handle<Object>> literals[] = {
       std::make_pair("return /abd/.exec('cccabbdd');\n",
                      factory->null_value()),
       std::make_pair("return /ab+d/.exec('cccabbdd')[0];\n",
                      factory->NewStringFromStaticChars("abbd")),
       std::make_pair("return /AbC/i.exec('ssaBC')[0];\n",
                      factory->NewStringFromStaticChars("aBC")),
       std::make_pair("return 'ssaBC'.match(/AbC/i)[0];\n",
                      factory->NewStringFromStaticChars("aBC")),
       std::make_pair("return 'ssaBCtAbC'.match(/(AbC)/gi)[1];\n",
                      factory->NewStringFromStaticChars("AbC")),
   };
 
   for (size_t i = 0; i < arraysize(literals); i++) {
     std::string source(InterpreterTester::SourceForBody(literals[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(*literals[i].second));
   }
 }
 
 
 TEST(InterpreterArrayLiterals) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
-  std::pair<const char*, Handle<Object>> literals[6] = {
+  std::pair<const char*, Handle<Object>> literals[] = {
       std::make_pair("return [][0];\n",
                      factory->undefined_value()),
       std::make_pair("return [1, 3, 2][1];\n",
                      handle(Smi::FromInt(3), isolate)),
       std::make_pair("return ['a', 'b', 'c'][2];\n",
                      factory->NewStringFromStaticChars("c")),
       std::make_pair("var a = 100; return [a, a + 1, a + 2, a + 3][2];\n",
                      handle(Smi::FromInt(102), isolate)),
       std::make_pair("return [[1, 2, 3], ['a', 'b', 'c']][1][0];\n",
                      factory->NewStringFromStaticChars("a")),
@@ skipping 10 matching lines @@
     CHECK(return_value->SameValue(*literals[i].second));
   }
 }
 
 
 TEST(InterpreterObjectLiterals) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
-  std::pair<const char*, Handle<Object>> literals[14] = {
+  std::pair<const char*, Handle<Object>> literals[] = {
       std::make_pair("return { }.name;",
                      factory->undefined_value()),
       std::make_pair("return { name: 'string', val: 9.2 }.name;",
                      factory->NewStringFromStaticChars("string")),
       std::make_pair("var a = 15; return { name: 'string', val: a }.val;",
                      handle(Smi::FromInt(15), isolate)),
       std::make_pair("var a = 5; return { val: a, val: a + 1 }.val;",
                      handle(Smi::FromInt(6), isolate)),
       std::make_pair("return { func: function() { return 'test' } }.func();",
                      factory->NewStringFromStaticChars("test")),
@@ skipping 90 matching lines @@
 
   Handle<Object> return_val = callable().ToHandleChecked();
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(15));
 }
 
 
 TEST(InterpreterContextVariables) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
 
-  std::pair<const char*, Handle<Object>> context_vars[5] = {
+  std::pair<const char*, Handle<Object>> context_vars[] = {
       std::make_pair("var a; (function() { a = 1; })(); return a;",
                      handle(Smi::FromInt(1), isolate)),
       std::make_pair("var a = 10; (function() { a; })(); return a;",
                      handle(Smi::FromInt(10), isolate)),
       std::make_pair("var a = 20; var b = 30;\n"
                      "return (function() { return a + b; })();",
                      handle(Smi::FromInt(50), isolate)),
       std::make_pair("'use strict'; let a = 1;\n"
                      "{ let b = 2; return (function() { return a + b; })(); }",
                      handle(Smi::FromInt(3), isolate)),
@@ skipping 11 matching lines @@
     Handle<i::Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*context_vars[i].second));
   }
 }
 
 
 TEST(InterpreterContextParameters) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
 
-  std::pair<const char*, Handle<Object>> context_params[3] = {
+  std::pair<const char*, Handle<Object>> context_params[] = {
       std::make_pair("return (function() { return arg1; })();",
                      handle(Smi::FromInt(1), isolate)),
       std::make_pair("(function() { arg1 = 4; })(); return arg1;",
                      handle(Smi::FromInt(4), isolate)),
       std::make_pair("(function() { arg3 = arg2 - arg1; })(); return arg3;",
                      handle(Smi::FromInt(1), isolate)),
   };
 
   for (size_t i = 0; i < arraysize(context_params); i++) {
     std::string source = "function " + InterpreterTester::function_name() +
                          "(arg1, arg2, arg3) {" + context_params[i].first + "}";
     InterpreterTester tester(handles.main_isolate(), source.c_str());
     auto callable =
         tester.GetCallable<Handle<Object>, Handle<Object>, Handle<Object>>();
 
     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::pair<const char*, Handle<Object>> context_vars[] = {
       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) {"
@@ skipping 13 matching lines @@
     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::pair<const char*, Handle<Object>> literals[] = {
       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",
                      factory->NewStringFromStaticChars("c")),
       std::make_pair("return 3.2, 2.3, 4.5;\n", factory->NewNumber(4.5)),
       std::make_pair("var a = 10; return b = a, b = b+1;\n",
                      handle(Smi::FromInt(11), isolate)),
       std::make_pair("var a = 10; return b = a, b = b+1, b + 10;\n",
                      handle(Smi::FromInt(21), isolate))};
 
   for (size_t i = 0; i < arraysize(literals); i++) {
     std::string source(InterpreterTester::SourceForBody(literals[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(*literals[i].second));
   }
 }
 
 
 TEST(InterpreterLogicalOr) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
-  std::pair<const char*, Handle<Object>> literals[5] = {
+  std::pair<const char*, Handle<Object>> literals[] = {
       std::make_pair("var a, b; return a || b;\n", factory->undefined_value()),
       std::make_pair("var a, b = 10; return a || b;\n",
                      handle(Smi::FromInt(10), isolate)),
       std::make_pair("var a = '0', b = 10; return a || b;\n",
                      factory->NewStringFromStaticChars("0")),
       std::make_pair("return 0 || 3.2;\n", factory->NewNumber(3.2)),
       std::make_pair("return 'a' || 0;\n",
                      factory->NewStringFromStaticChars("a"))};
 
   for (size_t i = 0; i < arraysize(literals); i++) {
     std::string source(InterpreterTester::SourceForBody(literals[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(*literals[i].second));
   }
 }
 
 
 TEST(InterpreterLogicalAnd) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
-  std::pair<const char*, Handle<Object>> literals[7] = {
+  std::pair<const char*, Handle<Object>> literals[] = {
       std::make_pair("var a, b = 10; return a && b;\n",
                      factory->undefined_value()),
       std::make_pair("var a = 0, b = 10; return a && b / a;\n",
                      handle(Smi::FromInt(0), isolate)),
       std::make_pair("var a = '0', b = 10; return a && b;\n",
                      handle(Smi::FromInt(10), isolate)),
       std::make_pair("return 0.0 && 3.2;\n",
                      handle(Smi::FromInt(0), isolate)),
       std::make_pair("return 'a' && 'b';\n",
                      factory->NewStringFromStaticChars("b")),
@@ skipping 40 matching lines @@
   CHECK_EQ(Smi::cast(*return_val), Smi::FromInt(4));
 }
 
 
 TEST(InterpreterThrow) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
   // TODO(rmcilroy): modify tests when we have real try catch support.
-  std::pair<const char*, Handle<Object>> throws[6] = {
+  std::pair<const char*, Handle<Object>> throws[] = {
       std::make_pair("throw undefined;\n",
                      factory->undefined_value()),
       std::make_pair("throw 1;\n",
                      handle(Smi::FromInt(1), isolate)),
       std::make_pair("throw 'Error';\n",
                      factory->NewStringFromStaticChars("Error")),
       std::make_pair("var a = true; if (a) { throw 'Error'; }\n",
                      factory->NewStringFromStaticChars("Error")),
       std::make_pair("var a = false; if (a) { throw 'Error'; }\n",
                      factory->undefined_value()),
@@ skipping 12 matching lines @@
     CHECK(thrown_obj->SameValue(*throws[i].second));
   }
 }
 
 
 TEST(InterpreterCountOperators) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
-  std::pair<const char*, Handle<Object>> count_ops[16] = {
+  std::pair<const char*, Handle<Object>> count_ops[] = {
       std::make_pair("var a = 1; return ++a;",
                      handle(Smi::FromInt(2), isolate)),
       std::make_pair("var a = 1; return a++;",
                      handle(Smi::FromInt(1), isolate)),
       std::make_pair("var a = 5; return --a;",
                      handle(Smi::FromInt(4), isolate)),
       std::make_pair("var a = 5; return a--;",
                      handle(Smi::FromInt(5), isolate)),
       std::make_pair("var a = 5.2; return --a;",
                      factory->NewHeapNumber(4.2)),
@@ skipping 29 matching lines @@
     Handle<i::Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*count_ops[i].second));
   }
 }
 
 
 TEST(InterpreterGlobalCountOperators) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
 
-  std::pair<const char*, Handle<Object>> count_ops[6] = {
+  std::pair<const char*, Handle<Object>> count_ops[] = {
       std::make_pair("var global = 100;function f(){ return ++global; }",
                      handle(Smi::FromInt(101), isolate)),
       std::make_pair("var global = 100; function f(){ return --global; }",
                      handle(Smi::FromInt(99), isolate)),
       std::make_pair("var global = 100; function f(){ return global++; }",
                      handle(Smi::FromInt(100), isolate)),
       std::make_pair("unallocated = 200; function f(){ return ++unallocated; }",
                      handle(Smi::FromInt(201), isolate)),
       std::make_pair("unallocated = 200; function f(){ return --unallocated; }",
                      handle(Smi::FromInt(199), isolate)),
       std::make_pair("unallocated = 200; function f(){ return unallocated++; }",
                      handle(Smi::FromInt(200), isolate)),
   };
 
   for (size_t i = 0; i < arraysize(count_ops); i++) {
     InterpreterTester tester(handles.main_isolate(), count_ops[i].first);
     auto callable = tester.GetCallable<>();
 
     Handle<i::Object> return_value = callable().ToHandleChecked();
     CHECK(return_value->SameValue(*count_ops[i].second));
   }
 }
 
 
 TEST(InterpreterCompoundExpressions) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
-  std::pair<const char*, Handle<Object>> compound_expr[5] = {
+  std::pair<const char*, Handle<Object>> compound_expr[] = {
       std::make_pair("var a = 1; a += 2; return a;",
                      Handle<Object>(Smi::FromInt(3), isolate)),
       std::make_pair("var a = 10; a /= 2; return a;",
                      Handle<Object>(Smi::FromInt(5), isolate)),
       std::make_pair("var a = 'test'; a += 'ing'; return a;",
                      factory->NewStringFromStaticChars("testing")),
       std::make_pair("var a = { val: 2 }; a.val *= 2; return a.val;",
                      Handle<Object>(Smi::FromInt(4), isolate)),
       std::make_pair("var a = 1; (function f() { a = 2; })(); a += 24;"
                      "return a;",
@@ skipping 33 matching lines @@
     CHECK(return_value->SameValue(*compound_expr[i].second));
   }
 }
 
 
 TEST(InterpreterCreateArguments) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
 
-  std::pair<const char*, int> create_args[9] = {
+  std::pair<const char*, int> create_args[] = {
       std::make_pair("function f() { return arguments[0]; }", 0),
       std::make_pair("function f(a) { return arguments[0]; }", 0),
       std::make_pair("function f() { return arguments[2]; }", 2),
       std::make_pair("function f(a) { return arguments[2]; }", 2),
       std::make_pair("function f(a, b, c, d) { return arguments[2]; }", 2),
       std::make_pair("function f(a) {"
                      "'use strict'; return arguments[0]; }",
                      0),
       std::make_pair("function f(a, b, c, d) {"
                      "'use strict'; return arguments[2]; }",
@@ skipping 43 matching lines @@
         callable(args[0], args[1], args[2]).ToHandleChecked();
     CHECK(return_val->SameValue(*args[create_args[i].second]));
   }
 }
 
 
 TEST(InterpreterConditional) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
 
-  std::pair<const char*, Handle<Object>> conditional[8] = {
+  std::pair<const char*, Handle<Object>> conditional[] = {
       std::make_pair("return true ? 2 : 3;",
                      handle(Smi::FromInt(2), isolate)),
       std::make_pair("return false ? 2 : 3;",
                      handle(Smi::FromInt(3), isolate)),
       std::make_pair("var a = 1; return a ? 20 : 30;",
                      handle(Smi::FromInt(20), isolate)),
       std::make_pair("var a = 1; return a ? 20 : 30;",
                      handle(Smi::FromInt(20), isolate)),
       std::make_pair("var a = 'string'; return a ? 20 : 30;",
                      handle(Smi::FromInt(20), isolate)),
@@ skipping 361 matching lines @@
        0}};
 
   for (size_t i = 0; i < arraysize(for_in_samples); i++) {
     InterpreterTester tester(handles.main_isolate(), for_in_samples[i].first);
     auto callable = tester.GetCallable<>();
     Handle<Object> return_val = callable().ToHandleChecked();
     CHECK_EQ(Handle<Smi>::cast(return_val)->value(), for_in_samples[i].second);
   }
 }
 
+
+TEST(InterpreterSwitch) {
+  HandleAndZoneScope handles;
+  i::Isolate* isolate = handles.main_isolate();
+  i::Factory* factory = isolate->factory();
+
+  std::pair<const char*, Handle<Object>> switch_ops[] = {
+      std::make_pair("var a = 1;\n"
+                     "switch(a) {\n"
+                     " case 1: return 2;\n"
+                     " case 2: return 3;\n"
+                     "}\n",
+                     handle(Smi::FromInt(2), isolate)),
+      std::make_pair("var a = 1;\n"
+                     "switch(a) {\n"
+                     " case 2: a = 2; break;\n"
+                     " case 1: a = 3; break;\n"
+                     "}\n"
+                     "return a;",
+                     handle(Smi::FromInt(3), isolate)),
+      std::make_pair("var a = 1;\n"
+                     "switch(a) {\n"
+                     " case 1: a = 2; // fall-through\n"
+                     " case 2: a = 3; break;\n"
+                     "}\n"
+                     "return a;",
+                     handle(Smi::FromInt(3), isolate)),
+      std::make_pair("var a = 100;\n"
+                     "switch(a) {\n"
+                     " case 1: return 100;\n"
+                     " case 2: return 200;\n"
+                     "}\n"
+                     "return undefined;",
+                     factory->undefined_value()),
+      std::make_pair("var a = 100;\n"
+                     "switch(a) {\n"
+                     " case 1: return 100;\n"
+                     " case 2: return 200;\n"
+                     " default: return 300;\n"
+                     "}\n"
+                     "return undefined;",
+                     handle(Smi::FromInt(300), isolate)),
+      std::make_pair("var a = 100;\n"
+                     "switch(typeof(a)) {\n"
+                     " case 'string': return 1;\n"
+                     " case 'number': return 2;\n"
+                     " default: return 3;\n"
+                     "}\n",
+                     handle(Smi::FromInt(2), isolate)),
+      std::make_pair("var a = 100;\n"
+                     "switch(a) {\n"
+                     " case a += 20: return 1;\n"
+                     " case a -= 10: return 2;\n"
+                     " case a -= 10: return 3;\n"
+                     " default: return 3;\n"
+                     "}\n",
+                     handle(Smi::FromInt(3), isolate)),
+      std::make_pair("var a = 1;\n"
+                     "switch(a) {\n"
+                     " case 1: \n"
+                     "   switch(a + 1) {\n"
+                     "      case 2 : a += 1; break;\n"
+                     "      default : a += 2; break;\n"
+                     "   }  // fall-through\n"
+                     " case 2: a += 3;\n"
+                     "}\n"
+                     "return a;",
+                     handle(Smi::FromInt(5), isolate)),
+  };
+
+  for (size_t i = 0; i < arraysize(switch_ops); i++) {
+    std::string source(InterpreterTester::SourceForBody(switch_ops[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(*switch_ops[i].second));
+  }
+}
+
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8