[jumbo] fix another set of unittest compilation errors

This makes jumbo_file_merge_limit=50 work again.

Bug: chromium:770684
Change-Id: I5db6566da876d71ea6ba50ff03b7652074b0a35f
Reviewed-on: https://chromium-review.googlesource.com/725818Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Commit-Queue: Mostyn Bramley-Moore <mostynb@vewd.com>
Cr-Commit-Position: refs/heads/master@{#48728}

src/interpreter/bytecode-array-writer.h

@@ -22,6 +22,10 @@ class BytecodeNode;
 class BytecodeJumpTable;
 class ConstantArrayBuilder;
 
+namespace bytecode_array_writer_unittest {
+class BytecodeArrayWriterUnittest;
+}  // namespace bytecode_array_writer_unittest
+
 // Class for emitting bytecode as the final stage of the bytecode
 // generation pipeline.
 class V8_EXPORT_PRIVATE BytecodeArrayWriter final {
@@ -92,7 +96,7 @@ class V8_EXPORT_PRIVATE BytecodeArrayWriter final {
 
   bool exit_seen_in_block_;
 
-  friend class BytecodeArrayWriterUnittest;
+  friend class bytecode_array_writer_unittest::BytecodeArrayWriterUnittest;
   DISALLOW_COPY_AND_ASSIGN(BytecodeArrayWriter);
 };
 

test/unittests/compiler/machine-operator-unittest.cc

@@ -11,6 +11,7 @@
 namespace v8 {
 namespace internal {
 namespace compiler {
+namespace machine_operator_unittest {
 
 #if GTEST_HAS_COMBINE
 
@@ -31,8 +32,6 @@ class MachineOperatorTestWithParam
 };
 
 
-namespace {
-
 const MachineRepresentation kMachineReps[] = {MachineRepresentation::kWord32,
                                               MachineRepresentation::kWord64};
 
@@ -50,8 +49,6 @@ const MachineRepresentation kRepresentationsForStore[] = {
     MachineRepresentation::kWord32,  MachineRepresentation::kWord64,
     MachineRepresentation::kTagged};
 
-}  // namespace
-
 
 // -----------------------------------------------------------------------------
 // Load operator.
@@ -169,8 +166,6 @@ INSTANTIATE_TEST_CASE_P(
 // -----------------------------------------------------------------------------
 // Pure operators.
 
-namespace {
-
 struct PureOperator {
   const Operator* (MachineOperatorBuilder::*constructor)();
   char const* const constructor_name;
@@ -269,7 +264,6 @@ const PureOperator kPureOperators[] = {
 #undef PURE
 };
 
-}  // namespace
 
 class MachinePureOperatorTest : public TestWithZone {
  protected:
@@ -299,8 +293,6 @@ TEST_F(MachinePureOperatorTest, PureOperators) {
 
 // Optional operators.
 
-namespace {
-
 struct OptionalOperatorEntry {
   const OptionalOperator (MachineOperatorBuilder::*constructor)();
   MachineOperatorBuilder::Flag enabling_flag;
@@ -327,7 +319,6 @@ const OptionalOperatorEntry kOptionalOperators[] = {
     OPTIONAL_ENTRY(Float64RoundTiesAway, 1, 0, 1),  // --
 #undef OPTIONAL_ENTRY
 };
-}  // namespace
 
 
 class MachineOptionalOperatorTest : public TestWithZone {
@@ -365,12 +356,8 @@ TEST_F(MachineOptionalOperatorTest, OptionalOperators) {
 // Pseudo operators.
 
 
-namespace {
-
 typedef TestWithZone MachineOperatorTest;
 
-}  // namespace
-
 
 TEST_F(MachineOperatorTest, PseudoOperatorsWhenWordSizeIs32Bit) {
   MachineOperatorBuilder machine(zone(), MachineRepresentation::kWord32);
@@ -415,6 +402,7 @@ TEST_F(MachineOperatorTest, PseudoOperatorsWhenWordSizeIs64Bit) {
   EXPECT_EQ(machine.Int64LessThanOrEqual(), machine.IntLessThanOrEqual());
 }
 
+}  // namespace machine_operator_unittest
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8

test/unittests/compiler/node-unittest.cc

@@ -15,12 +15,11 @@ using testing::UnorderedElementsAre;
 namespace v8 {
 namespace internal {
 namespace compiler {
+namespace node_unittest {
 
 typedef TestWithZone NodeTest;
 
 
-namespace {
-
 const IrOpcode::Value kOpcode0 = static_cast<IrOpcode::Value>(0);
 const IrOpcode::Value kOpcode1 = static_cast<IrOpcode::Value>(1);
 const IrOpcode::Value kOpcode2 = static_cast<IrOpcode::Value>(2);
@@ -29,8 +28,6 @@ const Operator kOp0(kOpcode0, Operator::kNoProperties, "Op0", 0, 0, 0, 1, 0, 0);
 const Operator kOp1(kOpcode1, Operator::kNoProperties, "Op1", 1, 0, 0, 1, 0, 0);
 const Operator kOp2(kOpcode2, Operator::kNoProperties, "Op2", 2, 0, 0, 1, 0, 0);
 
-}  // namespace
-
 
 TEST_F(NodeTest, New) {
   Node* const node = Node::New(zone(), 1, &kOp0, 0, nullptr, false);
@@ -261,7 +258,7 @@ TEST_F(NodeTest, BigNodes) {
   }
 }
 
-
+}  // namespace node_unittest
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8

test/unittests/compiler/simplified-operator-unittest.cc

@@ -12,12 +12,11 @@
 namespace v8 {
 namespace internal {
 namespace compiler {
+namespace simplified_operator_unittest {
 
 // -----------------------------------------------------------------------------
-// Pure operators.
-
 
-namespace {
+// Pure operators.
 
 struct PureOperator {
   const Operator* (SimplifiedOperatorBuilder::*constructor)();
@@ -71,8 +70,6 @@ const PureOperator kPureOperators[] = {
 #undef PURE
 };
 
-}  // namespace
-
 
 class SimplifiedPureOperatorTest
     : public TestWithZone,
@@ -123,10 +120,8 @@ INSTANTIATE_TEST_CASE_P(SimplifiedOperatorTest, SimplifiedPureOperatorTest,
 
 
 // -----------------------------------------------------------------------------
-// Element access operators.
-
 
-namespace {
+// Element access operators.
 
 const ElementAccess kElementAccesses[] = {
     {kTaggedBase, FixedArray::kHeaderSize, Type::Any(),
@@ -171,8 +166,6 @@ const ElementAccess kElementAccesses[] = {
      MachineType(MachineRepresentation::kFloat32, MachineSemantic::kNone),
      kNoWriteBarrier}};
 
-}  // namespace
-
 
 class SimplifiedElementAccessOperatorTest
     : public TestWithZone,
@@ -225,6 +218,7 @@ INSTANTIATE_TEST_CASE_P(SimplifiedOperatorTest,
                         SimplifiedElementAccessOperatorTest,
                         ::testing::ValuesIn(kElementAccesses));
 
+}  // namespace simplified_operator_unittest
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8

test/unittests/compiler/value-numbering-reducer-unittest.cc

@@ -13,6 +13,7 @@
 namespace v8 {
 namespace internal {
 namespace compiler {
+namespace value_numbering_reducer_unittest {
 
 struct TestOperator : public Operator {
   TestOperator(Operator::Opcode opcode, Operator::Properties properties,
@@ -126,6 +127,7 @@ TEST_F(ValueNumberingReducerTest, WontReplaceNodeWithItself) {
   EXPECT_FALSE(Reduce(n).Changed());
 }
 
+}  // namespace value_numbering_reducer_unittest
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8

test/unittests/interpreter/bytecode-array-writer-unittest.cc

@@ -22,6 +22,7 @@
 namespace v8 {
 namespace internal {
 namespace interpreter {
+namespace bytecode_array_writer_unittest {
 
 #define R(i) static_cast<uint32_t>(Register(i).ToOperand())
 
@@ -363,6 +364,9 @@ TEST_F(BytecodeArrayWriterUnittest, DeadcodeElimination) {
   CHECK(source_iterator.done());
 }
 
+#undef R
+
+}  // namespace bytecode_array_writer_unittest
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8

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

@@ -20,6 +20,7 @@ namespace c = v8::internal::compiler;
 namespace v8 {
 namespace internal {
 namespace interpreter {
+namespace interpreter_assembler_unittest {
 
 InterpreterAssemblerTestState::InterpreterAssemblerTestState(
     InterpreterAssemblerTest* test, Bytecode bytecode)
@@ -548,6 +549,7 @@ TARGET_TEST_F(InterpreterAssemblerTest, LoadFeedbackVector) {
   }
 }
 
+}  // namespace interpreter_assembler_unittest
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8

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

@@ -14,6 +14,7 @@
 namespace v8 {
 namespace internal {
 namespace interpreter {
+namespace interpreter_assembler_unittest {
 
 using ::testing::Matcher;
 
@@ -65,6 +66,7 @@ class InterpreterAssemblerTest : public TestWithIsolateAndZone {
   };
 };
 
+}  // namespace interpreter_assembler_unittest
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8