[Interpreter] Remove constant pool type in tests

test/cctest/interpreter/test-bytecode-generator.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 <fstream>
 
 #include "src/v8.h"
 
 #include "src/interpreter/bytecode-array-iterator.h"
 #include "src/interpreter/bytecode-generator.h"
@@ skipping 133 matching lines @@
     if (generated_line != expected_line) {
       std::cerr << "Inputs differ at line " << line_number << "\n";
       std::cerr << "  Generated: '" << generated_line << "'\n";
       std::cerr << "  Expected:  '" << expected_line << "'\n";
       return false;
     }
     line_number++;
   } while (true);
 }
 
-using ConstantPoolType = BytecodeExpectationsPrinter::ConstantPoolType;
-
 TEST(PrimitiveReturnStatements) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "",
 
       "return;\n",
 
       "return null;\n",
 
       "return true;\n",
 
       "return false;\n",
@@ skipping 10 matching lines @@
 
       "return 2.0;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("PrimitiveReturnStatements.golden")));
 }
 
 TEST(PrimitiveExpressions) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var x = 0; return x;\n",
 
       "var x = 0; return x + 3;\n",
 
       "var x = 0; return x - 3;\n",
 
       "var x = 4; return x * 3;\n",
 
       "var x = 4; return x / 3;\n",
@@ skipping 14 matching lines @@
 
       "var x = 0; return (x, 3);\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("PrimitiveExpressions.golden")));
 }
 
 TEST(LogicalExpressions) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var x = 0; return x || 3;\n",
 
       "var x = 0; return (x == 1) || 3;\n",
 
       "var x = 0; return x && 3;\n",
 
       "var x = 0; return (x == 0) && 3;\n",
 
       "var x = 0; return x || (1, 2, 3);\n",
@@ skipping 22 matching lines @@
 
       "var x = 1; return x && 3 || 0, 1;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("LogicalExpressions.golden")));
 }
 
 TEST(Parameters) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function f() { return this; }",
 
       "function f(arg1) { return arg1; }",
 
       "function f(arg1) { return this; }",
 
       "function f(arg1, arg2, arg3, arg4, arg5, arg6, arg7) { return arg4; }",
 
       "function f(arg1, arg2, arg3, arg4, arg5, arg6, arg7) { return this; }",
 
       "function f(arg1) { arg1 = 1; }",
 
       "function f(arg1, arg2, arg3, arg4) { arg2 = 1; }",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
                      LoadGolden("Parameters.golden")));
 }
 
 TEST(IntegerConstants) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "return 12345678;\n",
 
       "var a = 1234; return 5678;\n",
 
       "var a = 1234; return 1234;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("IntegerConstants.golden")));
 }
 
 TEST(HeapNumberConstants) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "return 1.2;\n",
 
       "var a = 1.2; return 2.6;\n",
 
       "var a = 3.14; return 3.14;\n",
 
       "var a;"                    //
       REPEAT_256("\na = 1.414;")  //
       " a = 3.14;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("HeapNumberConstants.golden")));
 }
 
 TEST(StringConstants) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "return \"This is a string\";\n",
 
       "var a = \"First string\"; return \"Second string\";\n",
 
       "var a = \"Same string\"; return \"Same string\";\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("StringConstants.golden")));
 }
 
 TEST(PropertyLoads) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
     "function f(a) { return a.name; }\n"
     "f({name : \"test\"});\n",
 
     "function f(a) { return a[\"key\"]; }\n"
     "f({key : \"test\"});\n",
 
@@ skipping 22 matching lines @@
     "}\n"
     "f({name : \"test\"}, \"name\")\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("PropertyLoads.golden")));
 }
 
 TEST(PropertyStores) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
     "function f(a) { a.name = \"val\"; }\n"
     "f({name : \"test\"})",
 
     "function f(a) { a[\"key\"] = \"val\"; }\n"
     "f({key : \"test\"})",
 
@@ skipping 44 matching lines @@
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("PropertyStores.golden")));
 }
 
 #define FUNC_ARG "new (function Obj() { this.func = function() { return; }})()"
 
 TEST(PropertyCall) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function f(a) { return a.func(); }\n"
       "f(" FUNC_ARG ")",
 
       "function f(a, b, c) { return a.func(b, c); }\n"
       "f(" FUNC_ARG ", 1, 2)",
 
       "function f(a, b) { return a.func(b + b, b); }\n"
       "f(" FUNC_ARG ", 1)",
 
       "function f(a) {\n"
       " a.func;\n"              //
       REPEAT_127(" a.func;\n")  //
       " return a.func(); }\n"
       "f(" FUNC_ARG ")",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("PropertyCall.golden")));
 }
 
 TEST(LoadGlobal) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
     "var a = 1;\n"
     "function f() { return a; }\n"
     "f()",
 
     "function t() { }\n"
     "function f() { return t; }\n"
@@ skipping 11 matching lines @@
     "}\n"
     "f({name: 1});\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("LoadGlobal.golden")));
 }
 
 TEST(StoreGlobal) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
     "var a = 1;\n"
     "function f() { a = 2; }\n"
     "f();\n",
 
     "var a = \"test\"; function f(b) { a = b; }\n"
     "f(\"global\");\n",
@@ skipping 23 matching lines @@
     "}\n"
     "f({name: 1});\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("StoreGlobal.golden")));
 }
 
 TEST(CallGlobal) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function t() { }\n"
       "function f() { return t(); }\n"
       "f();\n",
 
       "function t(a, b, c) { }\n"
       "function f() { return t(1, 2, 3); }\n"
       "f();\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("CallGlobal.golden")));
 }
 
 TEST(CallRuntime) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function f() { %TheHole() }\n"
       "f();\n",
 
       "function f(a) { return %IsArray(a) }\n"
       "f(undefined);\n",
 
       "function f() { return %Add(1, 2) }\n"
       "f();\n",
 
       "function f() { return %spread_iterable([1]) }\n"
       "f();\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("CallRuntime.golden")));
 }
 
 TEST(IfConditions) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
     "function f() {\n"
     "  if (0) {\n"
     "    return 1;\n"
     "  } else {\n"
     "    return -1;\n"
     "  }\n"
@@ skipping 93 matching lines @@
     "};\n"
     "f(-1, 1);\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("IfConditions.golden")));
 }
 
 TEST(DeclareGlobals) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
   printer.set_execute(false);
   printer.set_top_level(true);
 
   const char* snippets[] = {
       "var a = 1;\n",
 
       "function f() {}\n",
 
       "var a = 1;\n"
       "a=2;\n",
 
       "function f() {}\n"
       "f();\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("DeclareGlobals.golden")));
 }
 
 TEST(BreakableBlocks) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "var x = 0;\n"
       "label: {\n"
       "  x = x + 1;\n"
       "  break label;\n"
       "  x = x + 1;\n"
       "}\n"
       "return x;\n",
 
@@ skipping 25 matching lines @@
       "}\n"
       "x = 4;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("BreakableBlocks.golden")));
 }
 
 TEST(BasicLoops) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var x = 0;\n"
       "while (false) { x = 99; break; continue; }\n"
       "return x;\n",
 
       "var x = 0;\n"
       "while (false) {\n"
       "  x = x + 1;\n"
       "};\n"
       "return x;\n",
@@ skipping 132 matching lines @@
       "  }\n"
       "}\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("BasicLoops.golden")));
 }
 
 TEST(JumpsRequiringConstantWideOperands) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
     REPEAT_256("var x = 0.1;\n")
     REPEAT_32("var x = 0.2;\n")
     REPEAT_16("var x = 0.3;\n")
     REPEAT_8("var x = 0.4;\n")
     "for (var i = 0; i < 3; i++) {\n"
     "  if (i == 1) continue;\n"
     "  if (i == 2) break;\n"
     "}\n"
     "return 3;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("JumpsRequiringConstantWideOperands.golden")));
 }
 
 TEST(UnaryOperators) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var x = 0;\n"
       "while (x != 10) {\n"
       "  x = x + 10;\n"
       "}\n"
       "return x;\n",
 
       "var x = false;\n"
       "do {\n"
       "  x = !x;\n"
@@ skipping 16 matching lines @@
       "var x = 13;\n"
       "return -x;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("UnaryOperators.golden")));
 }
 
 TEST(Typeof) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function f() {\n"
       " var x = 13;\n"
       " return typeof(x);\n"
       "};",
 
       "var x = 13;\n"
       "function f() {\n"
       " return typeof(x);\n"
       "};",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
                      LoadGolden("Typeof.golden")));
 }
 
 TEST(Delete) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "var a = {x:13, y:14}; return delete a.x;\n",
 
       "'use strict'; var a = {x:13, y:14}; return delete a.x;\n",
 
       "var a = {1:13, 2:14}; return delete a[2];\n",
 
       "var a = 10; return delete a;\n",
 
       "'use strict';\n"
       "var a = {1:10};\n"
       "(function f1() {return a;});\n"
       "return delete a[1];\n",
 
       "return delete 'test';\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("Delete.golden")));
 }
 
 TEST(GlobalDelete) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "var a = {x:13, y:14};\n"
       "function f() {\n"
       "  return delete a.x;\n"
       "};\n"
       "f();\n",
 
@@ skipping 16 matching lines @@
       "};\n"
       "f();\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("GlobalDelete.golden")));
 }
 
 TEST(FunctionLiterals) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "return function(){ }\n",
 
       "return (function(){ })()\n",
 
       "return (function(x){ return x; })(1)\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("FunctionLiterals.golden")));
 }
 
 TEST(RegExpLiterals) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "return /ab+d/;\n",
 
       "return /(\\w+)\\s(\\w+)/i;\n",
 
       "return /ab+d/.exec('abdd');\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("RegExpLiterals.golden")));
 }
 
 TEST(RegExpLiteralsWide) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "var a;"                   //
       REPEAT_256("\na = 1.23;")  //
       "\nreturn /ab+d/;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("RegExpLiteralsWide.golden")));
 }
 
 TEST(ArrayLiterals) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "return [ 1, 2 ];\n",
 
       "var a = 1; return [ a, a + 1 ];\n",
 
       "return [ [ 1, 2 ], [ 3 ] ];\n",
 
       "var a = 1; return [ [ a, 2 ], [ a + 2 ] ];\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("ArrayLiterals.golden")));
 }
 
 TEST(ArrayLiteralsWide) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "var a;"                   //
       REPEAT_256("\na = 1.23;")  //
       "\nreturn [ 1 , 2 ];\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("ArrayLiteralsWide.golden")));
 }
 
 TEST(ObjectLiterals) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "return { };\n",
 
       "return { name: 'string', val: 9.2 };\n",
 
       "var a = 1; return { name: 'string', val: a };\n",
 
       "var a = 1; return { val: a, val: a + 1 };\n",
 
@@ skipping 19 matching lines @@
 
       "var n = 'name'; return { [n]: 'val', get a() { }, set a(b) {} };\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("ObjectLiterals.golden")));
 }
 
 TEST(ObjectLiteralsWide) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var a;"                   //
       REPEAT_256("\na = 1.23;")  //
       "\nreturn { name: 'string', val: 9.2 };\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("ObjectLiteralsWide.golden")));
 }
 
 TEST(TopLevelObjectLiterals) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
   printer.set_execute(false);
   printer.set_top_level(true);
 
   const char* snippets[] = {
       "var a = { func: function() { } };\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("TopLevelObjectLiterals.golden")));
 }
 
 TEST(TryCatch) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "try { return 1; } catch(e) { return 2; }\n",
 
       "var a;\n"
       "try { a = 1 } catch(e1) {};\n"
       "try { a = 2 } catch(e2) { a = 3 }\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("TryCatch.golden")));
 }
 
 TEST(TryFinally) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var a = 1;\n"
       "try { a = 2; } finally { a = 3; }\n",
 
       "var a = 1;\n"
       "try { a = 2; } catch(e) { a = 20 } finally { a = 3; }\n",
 
       "var a; try {\n"
       "  try { a = 1 } catch(e) { a = 2 }\n"
       "} catch(e) { a = 20 } finally { a = 3; }\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("TryFinally.golden")));
 }
 
 TEST(Throw) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "throw 1;\n",
 
       "throw 'Error';\n",
 
       "var a = 1; if (a) { throw 'Error'; };\n",
   };
 
   CHECK(
       CompareTexts(BuildActual(printer, snippets), LoadGolden("Throw.golden")));
 }
 
 TEST(CallNew) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function bar() { this.value = 0; }\n"
       "function f() { return new bar(); }\n"
       "f();\n",
 
       "function bar(x) { this.value = 18; this.x = x;}\n"
       "function f() { return new bar(3); }\n"
@@ skipping 13 matching lines @@
                      LoadGolden("CallNew.golden")));
 }
 
 TEST(ContextVariables) {
   // The wide check below relies on MIN_CONTEXT_SLOTS + 3 + 249 == 256, if this
   // ever changes, the REPEAT_XXX should be changed to output the correct number
   // of unique variables to trigger the wide slot load / store.
   STATIC_ASSERT(Context::MIN_CONTEXT_SLOTS + 3 + 249 == 256);
 
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
     "var a; return function() { a = 1; };\n",
 
     "var a = 1; return function() { a = 2; };\n",
 
     "var a = 1; var b = 2; return function() { a = 2; b = 3 };\n",
 
     "var a; (function() { a = 2; })(); return a;\n",
 
     "'use strict';\n"
     "let a = 1;\n"
     "{ let b = 2; return function() { a + b; }; }\n",
 
     "'use strict';\n"
     REPEAT_249_UNIQUE_VARS()
     "eval();\n"
     "var b = 100;\n"
     "return b\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("ContextVariables.golden")));
 }
 
 TEST(ContextParameters) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function f(arg1) { return function() { arg1 = 2; }; }",
 
       "function f(arg1) { var a = function() { arg1 = 2; }; return arg1; }",
 
       "function f(a1, a2, a3, a4) { return function() { a1 = a3; }; }",
 
       "function f() { var self = this; return function() { self = 2; }; }",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
                      LoadGolden("ContextParameters.golden")));
 }
 
 TEST(OuterContextVariables) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function Outer() {\n"
       "  var outerVar = 1;\n"
       "  function Inner(innerArg) {\n"
       "    this.innerFunc = function() { return outerVar * innerArg; }\n"
       "  }\n"
       "  this.getInnerFunc = function() { return new Inner(1).innerFunc; }\n"
       "}\n"
       "var f = new Outer().getInnerFunc();",
 
       "function Outer() {\n"
       "  var outerVar = 1;\n"
       "  function Inner(innerArg) {\n"
       "    this.innerFunc = function() { outerVar = innerArg; }\n"
       "  }\n"
       "  this.getInnerFunc = function() { return new Inner(1).innerFunc; }\n"
       "}\n"
       "var f = new Outer().getInnerFunc();",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
                      LoadGolden("OuterContextVariables.golden")));
 }
 
 TEST(CountOperators) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var a = 1; return ++a;\n",
 
       "var a = 1; return a++;\n",
 
       "var a = 1; return --a;\n",
 
       "var a = 1; return a--;\n",
 
       "var a = { val: 1 }; return a.val++;\n",
@@ skipping 10 matching lines @@
 
       "var idx = 1; var a = [1, 2]; return a[idx++] = 2;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("CountOperators.golden")));
 }
 
 TEST(GlobalCountOperators) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "var global = 1;\n"
       "function f() { return ++global; }\n"
       "f();\n",
 
       "var global = 1;\n"
       "function f() { return global--; }\n"
       "f();\n",
 
       "unallocated = 1;\n"
       "function f() { 'use strict'; return --unallocated; }\n"
       "f();\n",
 
       "unallocated = 1;\n"
       "function f() { return unallocated++; }\n"
       "f();\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("GlobalCountOperators.golden")));
 }
 
 TEST(CompoundExpressions) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var a = 1; a += 2;\n",
 
       "var a = 1; a /= 2;\n",
 
       "var a = { val: 2 }; a.name *= 2;\n",
 
       "var a = { 1: 2 }; a[1] ^= 2;\n",
 
       "var a = 1; (function f() { return a; }); a |= 24;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("CompoundExpressions.golden")));
 }
 
 TEST(GlobalCompoundExpressions) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "var global = 1;\n"
       "function f() { return global &= 1; }\n"
       "f();\n",
 
       "unallocated = 1;\n"
       "function f() { return unallocated += 1; }\n"
       "f();\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("GlobalCompoundExpressions.golden")));
 }
 
 TEST(CreateArguments) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function f() { return arguments; }",
 
       "function f() { return arguments[0]; }",
 
       "function f() { 'use strict'; return arguments; }",
 
       "function f(a) { return arguments[0]; }",
 
       "function f(a, b, c) { return arguments; }",
 
       "function f(a, b, c) { 'use strict'; return arguments; }",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
                      LoadGolden("CreateArguments.golden")));
 }
 
 TEST(CreateRestParameter) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function f(...restArgs) { return restArgs; }",
 
       "function f(a, ...restArgs) { return restArgs; }",
 
       "function f(a, ...restArgs) { return restArgs[0]; }",
 
       "function f(a, ...restArgs) { return restArgs[0] + arguments[0]; }",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
                      LoadGolden("CreateRestParameter.golden")));
 }
 
 TEST(ForIn) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "for (var p in null) {}\n",
 
       "for (var p in undefined) {}\n",
 
       "for (var p in undefined) {}\n",
 
       "var x = 'potatoes';\n"
       "for (var p in x) { return p; }\n",
 
       "var x = 0;\n"
       "for (var p in [1,2,3]) { x += p; }\n",
 
       "var x = { 'a': 1, 'b': 2 };\n"
       "for (x['a'] in [10, 20, 30]) {\n"
       "  if (x['a'] == 10) continue;\n"
       "  if (x['a'] == 20) break;\n"
       "}\n",
 
       "var x = [ 10, 11, 12 ] ;\n"
       "for (x[0] in [1,2,3]) { return x[3]; }\n",
   };
 
   CHECK(
       CompareTexts(BuildActual(printer, snippets), LoadGolden("ForIn.golden")));
 }
 
 TEST(ForOf) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "for (var p of [0, 1, 2]) {}\n",
 
       "var x = 'potatoes';\n"
       "for (var p of x) { return p; }\n",
 
       "for (var x of [10, 20, 30]) {\n"
       "  if (x == 10) continue;\n"
       "  if (x == 20) break;\n"
       "}\n",
 
       "var x = { 'a': 1, 'b': 2 };\n"
       "for (x['a'] of [1,2,3]) { return x['a']; }\n",
   };
 
   CHECK(
       CompareTexts(BuildActual(printer, snippets), LoadGolden("ForOf.golden")));
 }
 
 TEST(Conditional) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "return 1 ? 2 : 3;\n",
 
       "return 1 ? 2 ? 3 : 4 : 5;\n",
 
       "return 0 < 1 ? 2 : 3;\n",
 
       "var x = 0;\n"
       "return x ? 2 : 3;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("Conditional.golden")));
 }
 
 TEST(Switch) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
     "var a = 1;\n"
     "switch(a) {\n"
     " case 1: return 2;\n"
     " case 2: return 3;\n"
     "}\n",
 
     "var a = 1;\n"
     "switch(a) {\n"
     " case 1: a = 2; break;\n"
@@ skipping 46 matching lines @@
     " case 2: a = 3;\n"
     "}\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("Switch.golden")));
 }
 
 TEST(BasicBlockToBoolean) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var a = 1; if (a || a < 0) { return 1; }\n",
 
       "var a = 1; if (a && a < 0) { return 1; }\n",
 
       "var a = 1; a = (a || a < 0) ? 2 : 3;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("BasicBlockToBoolean.golden")));
 }
 
 TEST(DeadCodeRemoval) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "return; var a = 1; a();\n",
 
       "if (false) { return; }; var a = 1;\n",
 
       "if (true) { return 1; } else { return 2; };\n",
 
       "var a = 1; if (a) { return 1; }; return 2;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("DeadCodeRemoval.golden")));
 }
 
 TEST(ThisFunction) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "var f;\n"
       "f = function f() {};",
 
       "var f;\n"
       "f = function f() { return f; };",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets, "", "\nf();"),
                      LoadGolden("ThisFunction.golden")));
 }
 
 TEST(NewTarget) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "return new.target;\n",
 
       "new.target;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("NewTarget.golden")));
 }
 
 TEST(RemoveRedundantLdar) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var ld_a = 1;\n"          // This test is to check Ldar does not
       "while(true) {\n"          // get removed if the preceding Star is
       "  ld_a = ld_a + ld_a;\n"  // in a different basicblock.
       "  if (ld_a > 10) break;\n"
       "}\n"
       "return ld_a;\n",
 
       "var ld_a = 1;\n"
       "do {\n"
       "  ld_a = ld_a + ld_a;\n"
       "  if (ld_a > 10) continue;\n"
       "} while(false);\n"
       "return ld_a;\n",
 
       "var ld_a = 1;\n"
       "  ld_a = ld_a + ld_a;\n"
       "  return ld_a;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("RemoveRedundantLdar.golden")));
 }
 
 TEST(AssignmentsInBinaryExpression) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var x = 0, y = 1;\n"
       "return (x = 2, y = 3, x = 4, y = 5);\n",
 
       "var x = 55;\n"
       "var y = (x = 100);\n"
       "return y;\n",
 
       "var x = 55;\n"
       "x = x + (x = 100) + (x = 101);\n"
@@ skipping 19 matching lines @@
       "var x = 17;\n"
       "return 1 + x + (x++) + (++x);\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("AssignmentsInBinaryExpression.golden")));
 }
 
 TEST(Eval) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "return eval('1;');\n",
   };
 
   CHECK(
       CompareTexts(BuildActual(printer, snippets), LoadGolden("Eval.golden")));
 }
 
 TEST(LookupSlot) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
 
   const char* snippets[] = {
       "eval('var x = 10;'); return x;\n",
 
       "eval('var x = 10;'); return typeof x;\n",
 
       "x = 20; return eval('');\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("LookupSlot.golden")));
 }
 
 TEST(CallLookupSlot) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "g = function(){}; eval(''); return g();\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("CallLookupSlot.golden")));
 }
 
 // TODO(mythria): tests for variable/function declaration in lookup slots.
 
 TEST(LookupSlotInEval) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "return x;",
 
       "x = 10;",
 
       "'use strict'; x = 10;",
 
       "return typeof x;",
   };
 
   std::string actual = BuildActual(printer, snippets,
                                    "var f;\n"
                                    "var x = 1;\n"
                                    "function f1() {\n"
                                    "  eval(\"function t() { ",
 
                                    " }; f = t; f();\");\n"
                                    "}\n"
                                    "f1();");
 
   CHECK(CompareTexts(actual, LoadGolden("LookupSlotInEval.golden")));
 }
 
 TEST(LookupSlotWideInEval) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       REPEAT_256("    \"var y = 2.3;\" +\n")  //
       "    \"return x;\" +\n",
 
       REPEAT_256("    \"var y = 2.3;\" +\n")  //
       "    \"return typeof x;\" +\n",
 
@@ skipping 14 matching lines @@
                                    "  \"};\" +\n"
                                    "  \"f = t; f();\"\n);\n"
                                    "}\n"
                                    "f1();");
 
   CHECK(CompareTexts(actual, LoadGolden("LookupSlotWideInEval.golden")));
 }
 
 TEST(DeleteLookupSlotInEval) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "delete x;",
 
       "return delete y;",
 
       "return delete z;",
   };
@@ skipping 15 matching lines @@
 
 TEST(WideRegisters) {
   // Prepare prologue that creates frame for lots of registers.
   std::ostringstream os;
   for (size_t i = 0; i < 157; ++i) {
     os << "var x" << i << ";\n";
   }
   std::string prologue(os.str());
 
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kNumber);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "x0 = x127;\n"
       "return x0;\n",
 
       "x127 = x126;\n"
       "return x127;\n",
 
       "if (x2 > 3) { return x129; }\n"
       "return x128;\n",
 
@@ skipping 21 matching lines @@
       "%TheHole();\n"
       "return x1;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets, prologue.c_str()),
                      LoadGolden("WideRegisters.golden")));
 }
 
 TEST(ConstVariable) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "const x = 10;\n",
 
       "const x = 10; return x;\n",
 
       "const x = ( x = 20);\n",
 
       "const x = 10; x = 20;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("ConstVariable.golden")));
 }
 
 TEST(LetVariable) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "let x = 10;\n",
 
       "let x = 10; return x;\n",
 
       "let x = (x = 20);\n",
 
       "let x = 10; x = 20;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("LetVariable.golden")));
 }
 
 TEST(ConstVariableContextSlot) {
   // TODO(mythria): Add tests for initialization of this via super calls.
   // TODO(mythria): Add tests that walk the context chain.
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "const x = 10; function f1() {return x;}\n",
 
       "const x = 10; function f1() {return x;} return x;\n",
 
       "const x = (x = 20); function f1() {return x;}\n",
 
       "const x = 10; x = 20; function f1() {return x;}\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("ConstVariableContextSlot.golden")));
 }
 
 TEST(LetVariableContextSlot) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "let x = 10; function f1() {return x;}\n",
 
       "let x = 10; function f1() {return x;} return x;\n",
 
       "let x = (x = 20); function f1() {return x;}\n",
 
       "let x = 10; x = 20; function f1() {return x;}\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("LetVariableContextSlot.golden")));
 }
 
 TEST(DoExpression) {
   bool old_flag = FLAG_harmony_do_expressions;
   FLAG_harmony_do_expressions = true;
 
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "var a = do { }; return a;\n",
 
       "var a = do { var x = 100; }; return a;\n",
 
       "while(true) { var a = 10; a = do { ++a; break; }; a = 20; }\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("DoExpression.golden")));
 
   FLAG_harmony_do_expressions = old_flag;
 }
 
 TEST(WithStatement) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "with ({x:42}) { return x; }\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("WithStatement.golden")));
 }
 
 TEST(DoDebugger) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kString);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "debugger;\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("DoDebugger.golden")));
 }
 
 TEST(ClassDeclarations) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   const char* snippets[] = {
       "class Person {\n"
       "  constructor(name) { this.name = name; }\n"
       "  speak() { console.log(this.name + ' is speaking.'); }\n"
       "}\n",
 
       "class person {\n"
       "  constructor(name) { this.name = name; }\n"
       "  speak() { console.log(this.name + ' is speaking.'); }\n"
       "}\n",
 
       "var n0 = 'a';\n"
       "var n1 = 'b';\n"
       "class N {\n"
       "  [n0]() { return n0; }\n"
       "  static [n1]() { return n1; }\n"
       "}\n",
 
       "var count = 0;\n"
       "class C { constructor() { count++; }}\n"
       "return new C();\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("ClassDeclarations.golden")));
 }
 
 TEST(ClassAndSuperClass) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("test");
   const char* snippets[] = {
       "var test;\n"
       "(function() {\n"
       "  class A {\n"
       "    method() { return 2; }\n"
       "  }\n"
       "  class B extends A {\n"
       "    method() { return super.method() + 1; }\n"
@@ skipping 37 matching lines @@
       "  test = new B().constructor;\n"
       "})();\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("ClassAndSuperClass.golden")));
 }
 
 TEST(Generators) {
   InitializedIgnitionHandleScope scope;
-  BytecodeExpectationsPrinter printer(CcTest::isolate(),
-                                      ConstantPoolType::kMixed);
+  BytecodeExpectationsPrinter printer(CcTest::isolate());
   printer.set_wrap(false);
   printer.set_test_function_name("f");
 
   const char* snippets[] = {
       "function* f() { }\n"
       "f();\n",
 
       "function* f() { yield 42 }\n"
       "f();\n",
 
       "function* f() { for (let x of [42]) yield x }\n"
       "f();\n",
   };
 
   CHECK(CompareTexts(BuildActual(printer, snippets),
                      LoadGolden("Generators.golden")));
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8