[refactoring] Split CodeAssemblerState out of CodeAssembler

test/unittests/interpreter/interpreter-assembler-unittest.h

Index: test/unittests/interpreter/interpreter-assembler-unittest.h
diff --git a/test/unittests/interpreter/interpreter-assembler-unittest.h b/test/unittests/interpreter/interpreter-assembler-unittest.h
index e3e525273a983a85a8ba0a75d490837dba6a7b0e..9966aff172df99382591b0069edd4ab93f0e80e0 100644
--- a/test/unittests/interpreter/interpreter-assembler-unittest.h
+++ b/test/unittests/interpreter/interpreter-assembler-unittest.h
@@ -5,6 +5,7 @@
 #ifndef V8_UNITTESTS_INTERPRETER_INTERPRETER_ASSEMBLER_UNITTEST_H_
 #define V8_UNITTESTS_INTERPRETER_INTERPRETER_ASSEMBLER_UNITTEST_H_
 
+#include "src/compiler/code-assembler.h"
 #include "src/compiler/machine-operator.h"
 #include "src/interpreter/interpreter-assembler.h"
 #include "test/unittests/test-utils.h"
@@ -16,6 +17,14 @@ namespace interpreter {
 
 using ::testing::Matcher;
 
+class InterpreterAssemblerTest;
+
+class InterpreterAssemblerTestState : public compiler::CodeAssemblerState {

[Michael Starzinger, 2016/11/15 11:45:21]

Ah, now I see why making {CodeAssemblerState} wouldn't work right away. Could we
instead remove this helper class and make the {InterpreterAssemblerForTest}
class embed a {CodeAssemblerState} field. That way it is all packed into one
class and the unit tests don't need to care about a separate state at all.

[Igor Sheludko, 2016/11/15 13:06:35]

Or alternatively we can have a helper function that creates an
InterpreterAssemblerForTest from (InterpreterAssemblerTest* test, Bytecode
bytecode):
  InterpreterAssemblerForTest MakeInterpreterAssembler(InterpreterAssemblerTest*
test, Bytecode bytecode);

[Jakob Kummerow, 2016/11/15 13:40:32]

Summarizing offline discussion: we have several options:

(1) Keep this overriding class.

(2) This class is just convenience; what we do in its constructor, we could just
do at every instantiation site. That would significantly increase the amount of
boilerplate code in the test.

(3) Encapsulate the boilerplate, but without overriding. That would lead to a
similar solution as the CodeAssemblerTester used in other unit tests
(essentially, TestState has-a CodeAssemblerState instead of is-a).

(4) Embed a CodeAssemblerState into InterpreterAssemblerForTest. However, that
class derives from InterpreterAssembler and hence must pass a State* to its
super constructor. At the time of the super constructor call, its embedded
fields are not yet initialized. This seems brittle.

We agreed that option (1) is preferable over (2) - (4), so that's what we'll do
until we come up with a better idea.

+ public:
+  InterpreterAssemblerTestState(InterpreterAssemblerTest* test,
+                                Bytecode bytecode);
+};
+
 class InterpreterAssemblerTest : public TestWithIsolateAndZone {
  public:
   InterpreterAssemblerTest() {}
@@ -24,10 +33,9 @@ class InterpreterAssemblerTest : public TestWithIsolateAndZone {
   class InterpreterAssemblerForTest final : public InterpreterAssembler {
    public:
     InterpreterAssemblerForTest(
-        InterpreterAssemblerTest* test, Bytecode bytecode,
+        InterpreterAssemblerTestState* state, Bytecode bytecode,
         OperandScale operand_scale = OperandScale::kSingle)
-        : InterpreterAssembler(test->isolate(), test->zone(), bytecode,
-                               operand_scale) {}
+        : InterpreterAssembler(state, bytecode, operand_scale) {}
     ~InterpreterAssemblerForTest() override;
 
     Matcher<compiler::Node*> IsLoad(