Map::TryUpdate() must be in sync with Map::Update().

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"
 #include "src/compilation-cache.h"
 #include "src/execution.h"
 #include "src/factory.h"
 #include "src/global-handles.h"
 #include "src/ic/stub-cache.h"
 #include "src/macro-assembler.h"
 #include "src/smart-pointers.h"
 #include "test/cctest/cctest.h"
 
 using namespace v8::internal;
 
 
-// TODO(ishell): fix this once ReconfigureProperty supports "non equivalent"
-// transitions.
-const bool IS_NON_EQUIVALENT_TRANSITION_SUPPORTED = false;
-
-
 // TODO(ishell): fix this once TransitionToPrototype stops generalizing
 // all field representations (similar to crbug/448711 where elements kind
 // and observed transitions caused generalization of all field representations).
 const bool IS_PROTO_TRANS_ISSUE_FIXED = false;
 
 
 // TODO(ishell): fix this once TransitionToAccessorProperty is able to always
 // keep map in fast mode.
 const bool IS_ACCESSOR_FIELD_SUPPORTED = false;
 
@@ skipping 1546 matching lines @@
 
     CHECK(map->is_deprecated());
     CHECK_NE(*map, *new_map);
     CHECK(i == 0 || maps[i - 1]->is_deprecated());
     CHECK(expectations.Check(*new_map));
 
     Handle<Map> new_map2 = Map::Update(map2);
     CHECK(!new_map2->is_deprecated());
     CHECK(!new_map2->is_dictionary_map());
 
-    if (!IS_NON_EQUIVALENT_TRANSITION_SUPPORTED) {
+    Handle<Map> tmp_map;
+    if (Map::TryUpdate(map2).ToHandle(&tmp_map)) {
+      // If Map::TryUpdate() manages to succeed the result must match the result
+      // of Map::Update().
+      CHECK_EQ(*new_map2, *tmp_map);
+    }
+
+    if (config.is_non_equevalent_transition()) {
       // In case of non-equivalent transition currently we generalize all
       // representations.
       for (int i = 0; i < kPropCount; i++) {
         expectations2.GeneralizeRepresentation(i);
       }
       CHECK(new_map2->GetBackPointer()->IsUndefined());
       CHECK(expectations2.Check(*new_map2));
     } else {
-      CHECK(expectations.Check(*new_map2));
+      CHECK(!new_map2->GetBackPointer()->IsUndefined());
+      CHECK(expectations2.Check(*new_map2));
     }
   }
 
   Handle<Map> active_map = maps[kPropCount - 1];
   CHECK(!active_map->is_deprecated());
 
   // Update all deprecated maps and check that they are now the same.
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*active_map, *updated_map);
   for (int i = 0; i < kPropCount; i++) {
@@ skipping 11 matching lines @@
   Handle<HeapType> value_type =
       HeapType::Class(Map::Create(isolate, 0), isolate);
 
   struct TestConfig {
     Handle<Map> Transition(Handle<Map> map) {
       return Map::CopyAsElementsKind(map, DICTIONARY_ELEMENTS,
                                      INSERT_TRANSITION);
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const { return false; }
+    bool is_non_equevalent_transition() const { return false; }
   };
   TestConfig config;
   TestGeneralizeRepresentationWithSpecialTransition(
       config, Representation::Smi(), any_type, Representation::HeapObject(),
       value_type, Representation::Tagged(), any_type);
 }
 
 
 TEST(ElementsKindTransitionFromMapNotOwningDescriptor) {
   CcTest::InitializeVM();
@@ skipping 14 matching lines @@
       Map::CopyWithField(map, MakeString("foo"), any_type, NONE,
                          Representation::Smi(),
                          INSERT_TRANSITION).ToHandleChecked();
       CHECK(!map->owns_descriptors());
 
       return Map::CopyAsElementsKind(map, DICTIONARY_ELEMENTS,
                                      INSERT_TRANSITION);
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const { return false; }
+    bool is_non_equevalent_transition() const { return false; }
   };
   TestConfig config;
   TestGeneralizeRepresentationWithSpecialTransition(
       config, Representation::Smi(), any_type, Representation::HeapObject(),
       value_type, Representation::Tagged(), any_type);
 }
 
 
 TEST(ForObservedTransitionFromMapOwningDescriptor) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<HeapType> any_type = HeapType::Any(isolate);
   Handle<HeapType> value_type =
       HeapType::Class(Map::Create(isolate, 0), isolate);
 
   struct TestConfig {
     Handle<Map> Transition(Handle<Map> map) {
       return Map::CopyForObserved(map);
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const { return false; }
+    bool is_non_equevalent_transition() const { return true; }
   };
   TestConfig config;
   TestGeneralizeRepresentationWithSpecialTransition(
       config, Representation::Smi(), any_type, Representation::HeapObject(),
       value_type, Representation::Tagged(), any_type);
 }
 
 
 TEST(ForObservedTransitionFromMapNotOwningDescriptor) {
   CcTest::InitializeVM();
@@ skipping 13 matching lines @@
       CHECK(map->owns_descriptors());
       Map::CopyWithField(map, MakeString("foo"), any_type, NONE,
                          Representation::Smi(),
                          INSERT_TRANSITION).ToHandleChecked();
       CHECK(!map->owns_descriptors());
 
       return Map::CopyForObserved(map);
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const { return false; }
+    bool is_non_equevalent_transition() const { return true; }
   };
   TestConfig config;
   TestGeneralizeRepresentationWithSpecialTransition(
       config, Representation::Smi(), any_type, Representation::HeapObject(),
       value_type, Representation::Tagged(), any_type);
 }
 
 
 TEST(PrototypeTransitionFromMapOwningDescriptor) {
   CcTest::InitializeVM();
@@ skipping 13 matching lines @@
       prototype_ = factory->NewJSObjectFromMap(Map::Create(isolate, 0));
     }
 
     Handle<Map> Transition(Handle<Map> map) {
       return Map::TransitionToPrototype(map, prototype_, REGULAR_PROTOTYPE);
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const {
       return !IS_PROTO_TRANS_ISSUE_FIXED;
     }
+    bool is_non_equevalent_transition() const { return true; }
   };
   TestConfig config;
   TestGeneralizeRepresentationWithSpecialTransition(
       config, Representation::Smi(), any_type, Representation::HeapObject(),
       value_type, Representation::Tagged(), any_type);
 }
 
 
 TEST(PrototypeTransitionFromMapNotOwningDescriptor) {
   CcTest::InitializeVM();
@@ skipping 24 matching lines @@
                          Representation::Smi(),
                          INSERT_TRANSITION).ToHandleChecked();
       CHECK(!map->owns_descriptors());
 
       return Map::TransitionToPrototype(map, prototype_, REGULAR_PROTOTYPE);
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const {
       return !IS_PROTO_TRANS_ISSUE_FIXED;
     }
+    bool is_non_equevalent_transition() const { return true; }
   };
   TestConfig config;
   TestGeneralizeRepresentationWithSpecialTransition(
       config, Representation::Smi(), any_type, Representation::HeapObject(),
       value_type, Representation::Tagged(), any_type);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests for higher level transitioning mechanics.
@@ skipping 262 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)