[runtime] Remove redundant StoreMode enum.

test/cctest/test-field-type-tracking.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 "test/cctest/test-api.h"
 
 #include "src/v8.h"
@@ skipping 437 matching lines @@
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   map = expectations.AddAccessorConstant(map, NONE, pair);
 
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
   Handle<Map> new_map = Map::ReconfigureProperty(
-      map, 0, kData, NONE, Representation::None(), none_type, FORCE_FIELD);
+      map, 0, kData, NONE, Representation::None(), none_type);
   // |map| did not change except marked unstable.
   CHECK(!map->is_deprecated());
   CHECK(!map->is_stable());
   CHECK(expectations.Check(*map));
 
   expectations.SetDataField(0, NONE, Representation::None(), none_type);
 
   CHECK(!new_map->is_deprecated());
   CHECK(new_map->is_stable());
   CHECK(expectations.Check(*new_map));
 
   Handle<Map> new_map2 = Map::ReconfigureProperty(
-      map, 0, kData, NONE, Representation::None(), none_type, FORCE_FIELD);
+      map, 0, kData, NONE, Representation::None(), none_type);
   CHECK_EQ(*new_map, *new_map2);
 
   Handle<Object> value(Smi::kZero, isolate);
   Handle<Map> prepared_map = Map::PrepareForDataProperty(new_map, 0, value);
   // None to Smi generalization is trivial, map does not change.
   CHECK_EQ(*new_map, *prepared_map);
 
   expectations.SetDataField(0, NONE, Representation::Smi(), any_type);
   CHECK(prepared_map->is_stable());
   CHECK(expectations.Check(*prepared_map));
@@ skipping 103 matching lines @@
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   if (is_detached_map) {
     detach_point_map = Map::ReconfigureProperty(
         detach_point_map, detach_property_at_index, kData, NONE,
-        Representation::Tagged(), any_type, FORCE_FIELD);
+        Representation::Tagged(), any_type);
     expectations.SetDataField(detach_property_at_index,
                               Representation::Tagged(), any_type);
     CHECK(map->is_deprecated());
     CHECK(expectations.Check(*detach_point_map,
                              detach_point_map->NumberOfOwnDescriptors()));
   }
 
   // Create new maps by generalizing representation of propX field.
   Handle<Map> field_owner(map->FindFieldOwner(property_index), isolate);
   CompilationDependencies dependencies(isolate, &zone);
   CHECK(!dependencies.HasAborted());
 
   dependencies.AssumeFieldOwner(field_owner);
 
-  Handle<Map> new_map =
-      Map::ReconfigureProperty(map, property_index, kData, NONE,
-                               to_representation, to_type, FORCE_FIELD);
+  Handle<Map> new_map = Map::ReconfigureProperty(
+      map, property_index, kData, NONE, to_representation, to_type);
 
   expectations.SetDataField(property_index, expected_representation,
                             expected_type);
 
   CHECK(!new_map->is_deprecated());
   CHECK(expectations.Check(*new_map));
 
   if (is_detached_map) {
     CHECK(!map->is_stable());
     CHECK(map->is_deprecated());
@@ skipping 270 matching lines @@
 
   // Create new maps by generalizing representation of propX field.
   Handle<Map> maps[kPropCount];
   for (int i = 0; i < kPropCount; i++) {
     if (i == kAccessorProp) {
       // Skip accessor property reconfiguration.
       maps[i] = maps[i - 1];
       continue;
     }
     Handle<Map> new_map = Map::ReconfigureProperty(
-        map, i, kData, NONE, Representation::Double(), any_type, FORCE_FIELD);
+        map, i, kData, NONE, Representation::Double(), any_type);
     maps[i] = new_map;
 
     expectations.SetDataField(i, Representation::Double(), any_type);
 
     CHECK(!map->is_stable());
     CHECK(map->is_deprecated());
     CHECK_NE(*map, *new_map);
     CHECK(i == 0 || maps[i - 1]->is_deprecated());
 
     CHECK(!new_map->is_deprecated());
@@ skipping 933 matching lines @@
       }
 
       Handle<String> name = MakeName("prop", i);
       Map* target =
           TransitionArray::SearchTransition(*map2, kData, *name, NONE);
       CHECK(target != NULL);
       map2 = handle(target);
     }
 
     map2 = Map::ReconfigureProperty(map2, kSplitProp, kData, NONE,
-                                    Representation::Double(), any_type,
-                                    FORCE_FIELD);
+                                    Representation::Double(), any_type);
     expectations.SetDataField(kSplitProp, Representation::Double(), any_type);
 
     CHECK(expectations.Check(*split_map, kSplitProp));
     CHECK(expectations.Check(*map2, kSplitProp + 1));
   }
 
   // At this point |map| should be deprecated and disconnected from the
   // transition tree.
   CHECK(map->is_deprecated());
   CHECK(!split_map->is_deprecated());
@@ skipping 78 matching lines @@
     }
   }
 
   CHECK(!map2->is_deprecated());
   CHECK(map2->is_stable());
   CHECK(expectations2.Check(*map2));
 
   // Create new maps by generalizing representation of propX field.
   Handle<Map> maps[kPropCount];
   for (int i = 0; i < kPropCount; i++) {
-    Handle<Map> new_map = Map::ReconfigureProperty(
-        map, i, kData, NONE, to_representation, to_type, FORCE_FIELD);
+    Handle<Map> new_map = Map::ReconfigureProperty(map, i, kData, NONE,
+                                                   to_representation, to_type);
     maps[i] = new_map;
 
     expectations.SetDataField(i, expected_representation, expected_type);
 
     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);
@@ skipping 462 matching lines @@
   Isolate* isolate = CcTest::i_isolate();
 
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   CHECK_EQ(FieldType::Any()->Convert(&zone), AstType::NonInternal());
   CHECK_EQ(FieldType::None()->Convert(&zone), AstType::None());
 }
 
 // TODO(ishell): add this test once IS_ACCESSOR_FIELD_SUPPORTED is supported.
 // TEST(TransitionAccessorConstantToAnotherAccessorConstant)