Fix for the compilation failure due to multi-line comments in test-migrations.cc

test/cctest/test-migrations.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 <stdlib.h>
 #include <utility>
 
 #include "src/v8.h"
 
 #include "src/code-stubs.h"
@@ skipping 826 matching lines @@
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests for attribute reconfiguration case.
 //
 
 // This test ensures that representation/field type generalization is correctly
 // propagated from one branch of transition tree (|map2|) to another (|map|).
 //
-//               - p2B - p3 - p4: |map2|
-//              /
+//             + - p2B - p3 - p4: |map2|
+//             |
 //  {} - p0 - p1 - p2A - p3 - p4: |map|
 //
 // where "p2A" and "p2B" differ only in the attributes.
 //
 static void TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
     Representation from_representation, Handle<HeapType> from_type,
     Representation to_representation, Handle<HeapType> to_type,
     Representation expected_representation, Handle<HeapType> expected_type) {
   Isolate* isolate = CcTest::i_isolate();
 
@@ skipping 63 matching lines @@
 
   // Update deprecated |map|, it should become |new_map|.
   CHECK_EQ(*new_map, *Map::Update(map));
 }
 
 
 // This test ensures that trivial representation/field type generalization
 // (from HeapObject to HeapObject) is correctly propagated from one branch of
 // transition tree (|map2|) to another (|map|).
 //
-//               - p2B - p3 - p4: |map2|
-//              /
+//             + - p2B - p3 - p4: |map2|
+//             |
 //  {} - p0 - p1 - p2A - p3 - p4: |map|
 //
 // where "p2A" and "p2B" differ only in the attributes.
 //
 static void TestReconfigureDataFieldAttribute_GeneralizeRepresentationTrivial(
     Representation from_representation, Handle<HeapType> from_type,
     Representation to_representation, Handle<HeapType> to_type,
     Representation expected_representation, Handle<HeapType> expected_type,
     bool expected_field_type_dependency = true) {
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 209 matching lines @@
     CHECK(!new_map->is_deprecated());
     CHECK(!new_map->is_dictionary_map());
     CHECK(expectations.Check(*new_map));
   }
 };
 
 
 // This test ensures that representation/field type generalization is correctly
 // propagated from one branch of transition tree (|map2|) to another (|map1|).
 //
-//               - p2B - p3 - p4: |map2|
-//             /
+//             + - p2B - p3 - p4: |map2|
+//             |
 //  {} - p0 - p1: |map|
-//             \
-//               - p2A - p3 - p4: |map1|
-//                        \
-//                         - the property customized by the TestConfig provided
+//             |
+//             + - p2A - p3 - p4: |map1|
+//                        |
+//                        + - the property customized by the TestConfig provided
 //
 // where "p2A" and "p2B" differ only in the attributes.
 //
 template <typename TestConfig, typename Checker>
 static void TestReconfigureProperty_CustomPropertyAfterTargetMap(
     TestConfig& config, Checker& checker) {
   Isolate* isolate = CcTest::i_isolate();
   Handle<HeapType> any_type = HeapType::Any(isolate);
 
   const int kCustomPropIndex = kPropCount - 2;
@@ skipping 705 matching lines @@
 };
 
 
 // This test transitions to various property types under different
 // circumstances.
 // Plan:
 // 1) create a |map| with p0..p3 properties.
 // 2) create |map1| by adding "p4" to |map0|.
 // 3) create |map2| by transition to "p4" from |map0|.
 //
-//                         - p4B: |map2|
-//                       /
+//                       + - p4B: |map2|
+//                       |
 //  {} - p0 - p1 - pA - p3: |map|
-//                       \
-//                         - p4A: |map1|
+//                       |
+//                       + - p4A: |map1|
 //
 // where "p4A" and "p4B" differ only in the attributes.
 //
 template <typename TransitionOp1, typename TransitionOp2, typename Checker>
 static void TestTransitionTo(TransitionOp1& transition_op1,
                              TransitionOp2& transition_op2, Checker& checker) {
   Isolate* isolate = CcTest::i_isolate();
   Handle<HeapType> any_type = HeapType::Any(isolate);
 
   Expectations expectations(isolate);
@@ skipping 98 matching lines @@
   Handle<AccessorPair> pair = CreateAccessorPair(true, true);
   TransitionToAccessorConstantOperator transition_op(pair);
 
   SameMapChecker checker;
   TestTransitionTo(transition_op, transition_op, checker);
 }
 
 
 // TODO(ishell): add this test once IS_ACCESSOR_FIELD_SUPPORTED is supported.
 // TEST(TransitionAccessorConstantToAnotherAccessorConstant)