[runtime] Add PropertyConstness bit to PropertyDetails.

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 61 matching lines @@
   return pair;
 }
 
 
 class Expectations {
   static const int MAX_PROPERTIES = 10;
   Isolate* isolate_;
   ElementsKind elements_kind_;
   PropertyKind kinds_[MAX_PROPERTIES];
   PropertyLocation locations_[MAX_PROPERTIES];
+  PropertyConstness constnesses_[MAX_PROPERTIES];
   PropertyAttributes attributes_[MAX_PROPERTIES];
   Representation representations_[MAX_PROPERTIES];
   // FieldType for kField, value for DATA_CONSTANT and getter for
   // ACCESSOR_CONSTANT.
   Handle<Object> values_[MAX_PROPERTIES];
   // Setter for ACCESSOR_CONSTANT.
   Handle<Object> setter_values_[MAX_PROPERTIES];
   int number_of_properties_;
 
  public:
   explicit Expectations(Isolate* isolate, ElementsKind elements_kind)
       : isolate_(isolate),
         elements_kind_(elements_kind),
         number_of_properties_(0) {}
 
   explicit Expectations(Isolate* isolate)
       : Expectations(
             isolate,
             isolate->object_function()->initial_map()->elements_kind()) {}
 
   void Init(int index, PropertyKind kind, PropertyAttributes attributes,
-            PropertyLocation location, Representation representation,
-            Handle<Object> value) {
+            PropertyConstness constness, PropertyLocation location,
+            Representation representation, Handle<Object> value) {
     CHECK(index < MAX_PROPERTIES);
     kinds_[index] = kind;
     locations_[index] = location;
+    constnesses_[index] = constness;
     attributes_[index] = attributes;
     representations_[index] = representation;
     values_[index] = value;
   }
 
   void Print() const {
     OFStream os(stdout);
     os << "Expectations: #" << number_of_properties_ << "\n";
     for (int i = 0; i < number_of_properties_; i++) {
       os << " " << i << ": ";
       os << "Descriptor @ ";
 
       if (kinds_[i] == kData) {
         os << Brief(*values_[i]);
       } else {
         // kAccessor
         os << "(get: " << Brief(*values_[i])
            << ", set: " << Brief(*setter_values_[i]) << ") ";
       }
 
       os << " (";
+      if (constnesses_[i] == kConst) os << "const ";
       os << (kinds_[i] == kData ? "data " : "accessor ");
       if (locations_[i] == kField) {
         os << "field"
            << ": " << representations_[i].Mnemonic();
       } else {
         os << "descriptor";
       }
       os << ", attrs: " << attributes_[i] << ")\n";
     }
     os << "\n";
   }
 
   void SetElementsKind(ElementsKind elements_kind) {
     elements_kind_ = elements_kind;
   }
 
   Handle<FieldType> GetFieldType(int index) {
     CHECK(index < MAX_PROPERTIES);
     CHECK_EQ(kField, locations_[index]);
     return Handle<FieldType>::cast(values_[index]);
   }
 
   void SetDataField(int index, PropertyAttributes attrs,
+                    PropertyConstness constness, Representation representation,
+                    Handle<FieldType> field_type) {
+    Init(index, kData, attrs, constness, kField, representation, field_type);
+  }
+
+  void SetDataField(int index, PropertyConstness constness,
                     Representation representation,
                     Handle<FieldType> field_type) {
-    Init(index, kData, attrs, kField, representation, field_type);
-  }
-
-  void SetDataField(int index, Representation representation,
-                    Handle<FieldType> field_type) {
-    SetDataField(index, attributes_[index], representation, field_type);
+    SetDataField(index, attributes_[index], constness, representation,
+                 field_type);
   }
 
   void SetAccessorField(int index, PropertyAttributes attrs) {
-    Init(index, kAccessor, attrs, kDescriptor, Representation::Tagged(),
+    Init(index, kAccessor, attrs, kConst, kDescriptor, Representation::Tagged(),
          FieldType::Any(isolate_));
   }
 
   void SetAccessorField(int index) {
     SetAccessorField(index, attributes_[index]);
   }
 
   void SetDataConstant(int index, PropertyAttributes attrs,
                        Handle<JSFunction> value) {
-    Init(index, kData, attrs, kDescriptor, Representation::HeapObject(), value);
+    Init(index, kData, attrs, kConst, kDescriptor, Representation::HeapObject(),
+         value);
   }
 
   void SetDataConstant(int index, Handle<JSFunction> value) {
     SetDataConstant(index, attributes_[index], value);
   }
 
   void SetAccessorConstant(int index, PropertyAttributes attrs,
                            Handle<Object> getter, Handle<Object> setter) {
-    Init(index, kAccessor, attrs, kDescriptor, Representation::Tagged(),
+    Init(index, kAccessor, attrs, kConst, kDescriptor, Representation::Tagged(),
          getter);
     setter_values_[index] = setter;
   }
 
   void SetAccessorConstantComponent(int index, PropertyAttributes attrs,
                                     AccessorComponent component,
                                     Handle<Object> accessor) {
     CHECK_EQ(kAccessor, kinds_[index]);
     CHECK_EQ(kDescriptor, locations_[index]);
     CHECK(index < number_of_properties_);
@@ skipping 23 matching lines @@
   }
 
   void GeneralizeRepresentation(int index) {
     CHECK(index < number_of_properties_);
     representations_[index] = Representation::Tagged();
     if (locations_[index] == kField) {
       values_[index] = FieldType::Any(isolate_);
     }
   }
 
-
   bool Check(DescriptorArray* descriptors, int descriptor) const {
     PropertyDetails details = descriptors->GetDetails(descriptor);
 
     if (details.kind() != kinds_[descriptor]) return false;
     if (details.location() != locations_[descriptor]) return false;
+    if (details.constness() != constnesses_[descriptor]) return false;
 
     PropertyAttributes expected_attributes = attributes_[descriptor];
     if (details.attributes() != expected_attributes) return false;
 
     Representation expected_representation = representations_[descriptor];
     if (!details.representation().Equals(expected_representation)) return false;
 
     Object* value = descriptors->GetValue(descriptor);
     Object* expected_value = *values_[descriptor];
     if (details.location() == kField) {
@@ skipping 51 matching lines @@
   //
 
   Handle<Map> AsElementsKind(Handle<Map> map, ElementsKind elements_kind) {
     elements_kind_ = elements_kind;
     map = Map::AsElementsKind(map, elements_kind);
     CHECK_EQ(elements_kind_, map->elements_kind());
     return map;
   }
 
   Handle<Map> AddDataField(Handle<Map> map, PropertyAttributes attributes,
+                           PropertyConstness constness,
                            Representation representation,
                            Handle<FieldType> heap_type) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
-    SetDataField(property_index, attributes, representation, heap_type);
+    SetDataField(property_index, attributes, constness, representation,
+                 heap_type);
 
     Handle<String> name = MakeName("prop", property_index);
     return Map::CopyWithField(map, name, heap_type, attributes, representation,
                               INSERT_TRANSITION)
         .ToHandleChecked();
   }
 
   Handle<Map> AddDataConstant(Handle<Map> map, PropertyAttributes attributes,
                               Handle<JSFunction> value) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetDataConstant(property_index, attributes, value);
 
     Handle<String> name = MakeName("prop", property_index);
     return Map::CopyWithConstant(map, name, value, attributes,
                                  INSERT_TRANSITION)
         .ToHandleChecked();
   }
 
   Handle<Map> TransitionToDataField(Handle<Map> map,
                                     PropertyAttributes attributes,
+                                    PropertyConstness constness,
                                     Representation representation,
                                     Handle<FieldType> heap_type,
                                     Handle<Object> value) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
-    SetDataField(property_index, attributes, representation, heap_type);
+    SetDataField(property_index, attributes, constness, representation,
+                 heap_type);
 
     Handle<String> name = MakeName("prop", property_index);
     return Map::TransitionToDataProperty(
         map, name, value, attributes, Object::CERTAINLY_NOT_STORE_FROM_KEYED);
   }
 
   Handle<Map> TransitionToDataConstant(Handle<Map> map,
                                        PropertyAttributes attributes,
                                        Handle<JSFunction> value) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetDataConstant(property_index, attributes, value);
 
     Handle<String> name = MakeName("prop", property_index);
     return Map::TransitionToDataProperty(
         map, name, value, attributes, Object::CERTAINLY_NOT_STORE_FROM_KEYED);
   }
 
   Handle<Map> FollowDataTransition(Handle<Map> map,
                                    PropertyAttributes attributes,
+                                   PropertyConstness constness,
                                    Representation representation,
                                    Handle<FieldType> heap_type) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
-    SetDataField(property_index, attributes, representation, heap_type);
+    SetDataField(property_index, attributes, constness, representation,
+                 heap_type);
 
     Handle<String> name = MakeName("prop", property_index);
     Map* target =
         TransitionArray::SearchTransition(*map, kData, *name, attributes);
     CHECK(target != NULL);
     return handle(target);
   }
 
   Handle<Map> AddAccessorConstant(Handle<Map> map,
                                   PropertyAttributes attributes,
@@ skipping 84 matching lines @@
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
   Handle<Map> new_map = Map::ReconfigureProperty(
       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);
+  // Property kind reconfiguration always makes the field mutable.
+  expectations.SetDataField(0, NONE, kMutable, 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);
   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);
+  expectations.SetDataField(0, NONE, kMutable, Representation::Smi(), any_type);
   CHECK(prepared_map->is_stable());
   CHECK(expectations.Check(*prepared_map));
 
   // Now create an object with |map|, migrate it to |prepared_map| and ensure
   // that the data property is uninitialized.
   Factory* factory = isolate->factory();
   Handle<JSObject> obj = factory->NewJSObjectFromMap(map);
   JSObject::MigrateToMap(obj, prepared_map);
   FieldIndex index = FieldIndex::ForDescriptor(*prepared_map, 0);
   CHECK(obj->RawFastPropertyAt(index)->IsUninitialized(isolate));
@@ skipping 40 matching lines @@
   Object* the_value = obj->RawFastPropertyAt(index);
   CHECK(the_value->IsSmi());
   CHECK_EQ(42, Smi::cast(the_value)->value());
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests for representation generalization case.
 //
 
+// <Constness, Representation, FieldType> data.
+struct CRFTData {
+  PropertyConstness constness;
+  Representation representation;
+  Handle<FieldType> type;
+};
+
 // This test ensures that representation/field type generalization at
 // |property_index| is done correctly independently of the fact that the |map|
 // is detached from transition tree or not.
 //
 //  {} - p0 - p1 - p2: |detach_point_map|
 //                  |
 //                  X - detached at |detach_property_at_index|
 //                  |
 //                  + - p3 - p4: |map|
 //
 // Detaching does not happen if |detach_property_at_index| is -1.
 //
 static void TestGeneralizeRepresentation(
-    int detach_property_at_index, int property_index,
-    Representation from_representation, Handle<FieldType> from_type,
-    Representation to_representation, Handle<FieldType> to_type,
-    Representation expected_representation, Handle<FieldType> expected_type,
-    bool expected_deprecation, bool expected_field_type_dependency) {
+    int detach_property_at_index, int property_index, const CRFTData& from,
+    const CRFTData& to, const CRFTData& expected, bool expected_deprecation,
+    bool expected_field_type_dependency) {
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   CHECK(detach_property_at_index >= -1 &&
         detach_property_at_index < kPropCount);
   CHECK(property_index < kPropCount);
   CHECK_NE(detach_property_at_index, property_index);
 
   const bool is_detached_map = detach_property_at_index >= 0;
 
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   Handle<Map> detach_point_map;
   for (int i = 0; i < kPropCount; i++) {
     if (i == property_index) {
-      map =
-          expectations.AddDataField(map, NONE, from_representation, from_type);
+      map = expectations.AddDataField(map, NONE, from.constness,
+                                      from.representation, from.type);
     } else {
-      map =
-          expectations.AddDataField(map, NONE, Representation::Smi(), any_type);
+      map = expectations.AddDataField(map, NONE, kMutable,
+                                      Representation::Smi(), any_type);
       if (i == detach_property_at_index) {
         detach_point_map = map;
       }
     }
   }
   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);
-    expectations.SetDataField(detach_property_at_index,
+    expectations.SetDataField(detach_property_at_index, kMutable,
                               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);
+      map, property_index, kData, NONE, to.representation, to.type);
 
-  expectations.SetDataField(property_index, expected_representation,
-                            expected_type);
+  expectations.SetDataField(property_index, expected.constness,
+                            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());
     CHECK_NE(*map, *new_map);
     CHECK_EQ(expected_field_type_dependency && !field_owner->is_deprecated(),
              dependencies.HasAborted());
@@ skipping 24 matching lines @@
     }
   }
 
   dependencies.Rollback();  // Properly cleanup compilation info.
 
   // Update all deprecated maps and check that they are now the same.
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*new_map, *updated_map);
 }
 
-static void TestGeneralizeRepresentation(
-    Representation from_representation, Handle<FieldType> from_type,
-    Representation to_representation, Handle<FieldType> to_type,
-    Representation expected_representation, Handle<FieldType> expected_type,
-    bool expected_deprecation, bool expected_field_type_dependency) {
+static void TestGeneralizeRepresentation(const CRFTData& from,
+                                         const CRFTData& to,
+                                         const CRFTData& expected,
+                                         bool expected_deprecation,
+                                         bool expected_field_type_dependency) {
   // Check the cases when the map being reconfigured is a part of the
   // transition tree.
   STATIC_ASSERT(kPropCount > 4);
   int indices[] = {0, 2, kPropCount - 1};
   for (int i = 0; i < static_cast<int>(arraysize(indices)); i++) {
-    TestGeneralizeRepresentation(
-        -1, indices[i], from_representation, from_type, to_representation,
-        to_type, expected_representation, expected_type, expected_deprecation,
-        expected_field_type_dependency);
+    TestGeneralizeRepresentation(-1, indices[i], from, to, expected,
+                                 expected_deprecation,
+                                 expected_field_type_dependency);
   }
 
-  if (!from_representation.IsNone()) {
+  if (!from.representation.IsNone()) {
     // Check the cases when the map being reconfigured is NOT a part of the
     // transition tree. "None -> anything" representation changes make sense
     // only for "attached" maps.
     int indices[] = {0, kPropCount - 1};
     for (int i = 0; i < static_cast<int>(arraysize(indices)); i++) {
-      TestGeneralizeRepresentation(
-          indices[i], 2, from_representation, from_type, to_representation,
-          to_type, expected_representation, expected_type, expected_deprecation,
-          expected_field_type_dependency);
+      TestGeneralizeRepresentation(indices[i], 2, from, to, expected,
+                                   expected_deprecation,
+                                   expected_field_type_dependency);
     }
 
     // Check that reconfiguration to the very same field works correctly.
-    Representation representation = from_representation;
-    Handle<FieldType> type = from_type;
-    TestGeneralizeRepresentation(-1, 2, representation, type, representation,
-                                 type, representation, type, false, false);
+    CRFTData data = from;
+    TestGeneralizeRepresentation(-1, 2, data, data, data, false, false);
   }
 }
 
-static void TestGeneralizeRepresentation(Representation from_representation,
-                                         Handle<FieldType> from_type,
-                                         Representation to_representation,
-                                         Handle<FieldType> to_type,
-                                         Representation expected_representation,
-                                         Handle<FieldType> expected_type) {
+static void TestGeneralizeRepresentation(const CRFTData& from,
+                                         const CRFTData& to,
+                                         const CRFTData& expected) {
   const bool expected_deprecation = true;
   const bool expected_field_type_dependency = false;
 
-  TestGeneralizeRepresentation(
-      from_representation, from_type, to_representation, to_type,
-      expected_representation, expected_type, expected_deprecation,
-      expected_field_type_dependency);
+  TestGeneralizeRepresentation(from, to, expected, expected_deprecation,
+                               expected_field_type_dependency);
 }
 
 static void TestGeneralizeRepresentationTrivial(
-    Representation from_representation, Handle<FieldType> from_type,
-    Representation to_representation, Handle<FieldType> to_type,
-    Representation expected_representation, Handle<FieldType> expected_type,
+    const CRFTData& from, const CRFTData& to, const CRFTData& expected,
     bool expected_field_type_dependency = true) {
   const bool expected_deprecation = false;
 
-  TestGeneralizeRepresentation(
-      from_representation, from_type, to_representation, to_type,
-      expected_representation, expected_type, expected_deprecation,
-      expected_field_type_dependency);
+  TestGeneralizeRepresentation(from, to, expected, expected_deprecation,
+                               expected_field_type_dependency);
 }
 
 
 TEST(GeneralizeRepresentationSmiToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
-  TestGeneralizeRepresentation(Representation::Smi(), any_type,
-                               Representation::Double(), any_type,
-                               Representation::Double(), any_type);
+  TestGeneralizeRepresentation({kMutable, Representation::Smi(), any_type},
+                               {kMutable, Representation::Double(), any_type},
+                               {kMutable, Representation::Double(), any_type});
 }
 
 
 TEST(GeneralizeRepresentationSmiToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestGeneralizeRepresentation(Representation::Smi(), any_type,
-                               Representation::HeapObject(), value_type,
-                               Representation::Tagged(), any_type);
+  TestGeneralizeRepresentation(
+      {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(GeneralizeRepresentationDoubleToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestGeneralizeRepresentation(Representation::Double(), any_type,
-                               Representation::HeapObject(), value_type,
-                               Representation::Tagged(), any_type);
+  TestGeneralizeRepresentation(
+      {kMutable, Representation::Double(), any_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(GeneralizeRepresentationHeapObjectToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
-  TestGeneralizeRepresentation(Representation::HeapObject(), value_type,
-                               Representation::Smi(), any_type,
-                               Representation::Tagged(), any_type);
+  TestGeneralizeRepresentation(
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(GeneralizeRepresentationHeapObjectToHeapObject) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<FieldType> current_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> new_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> expected_type = any_type;
 
-    TestGeneralizeRepresentationTrivial(
-        Representation::HeapObject(), current_type,
-        Representation::HeapObject(), new_type, Representation::HeapObject(),
-        expected_type);
-    current_type = expected_type;
+  TestGeneralizeRepresentationTrivial(
+      {kMutable, Representation::HeapObject(), current_type},
+      {kMutable, Representation::HeapObject(), new_type},
+      {kMutable, Representation::HeapObject(), expected_type});
+  current_type = expected_type;
 
-    new_type = FieldType::Class(Map::Create(isolate, 0), isolate);
+  new_type = FieldType::Class(Map::Create(isolate, 0), isolate);
 
   TestGeneralizeRepresentationTrivial(
-      Representation::HeapObject(), any_type, Representation::HeapObject(),
-      new_type, Representation::HeapObject(), any_type, false);
+      {kMutable, Representation::HeapObject(), any_type},
+      {kMutable, Representation::HeapObject(), new_type},
+      {kMutable, Representation::HeapObject(), any_type}, false);
 }
 
 
 TEST(GeneralizeRepresentationNoneToSmi) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> none_type = FieldType::None(isolate);
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   // None -> Smi representation change is trivial.
-  TestGeneralizeRepresentationTrivial(Representation::None(), none_type,
-                                      Representation::Smi(), any_type,
-                                      Representation::Smi(), any_type);
+  TestGeneralizeRepresentationTrivial(
+      {kMutable, Representation::None(), none_type},
+      {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::Smi(), any_type});
 }
 
 
 TEST(GeneralizeRepresentationNoneToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> none_type = FieldType::None(isolate);
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   // None -> Double representation change is NOT trivial.
-  TestGeneralizeRepresentation(Representation::None(), none_type,
-                               Representation::Double(), any_type,
-                               Representation::Double(), any_type);
+  TestGeneralizeRepresentation({kMutable, Representation::None(), none_type},
+                               {kMutable, Representation::Double(), any_type},
+                               {kMutable, Representation::Double(), any_type});
 }
 
 
 TEST(GeneralizeRepresentationNoneToHeapObject) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> none_type = FieldType::None(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   // None -> HeapObject representation change is trivial.
-  TestGeneralizeRepresentationTrivial(Representation::None(), none_type,
-                                      Representation::HeapObject(), value_type,
-                                      Representation::HeapObject(), value_type);
+  TestGeneralizeRepresentationTrivial(
+      {kMutable, Representation::None(), none_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::HeapObject(), value_type});
 }
 
 
 TEST(GeneralizeRepresentationNoneToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> none_type = FieldType::None(isolate);
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   // None -> HeapObject representation change is trivial.
-  TestGeneralizeRepresentationTrivial(Representation::None(), none_type,
-                                      Representation::Tagged(), any_type,
-                                      Representation::Tagged(), any_type);
+  TestGeneralizeRepresentationTrivial(
+      {kMutable, Representation::None(), none_type},
+      {kMutable, Representation::Tagged(), any_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests for representation generalization case with kAccessor
 // properties.
 //
 
 TEST(GeneralizeRepresentationWithAccessorProperties) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<AccessorPair> pair = CreateAccessorPair(true, true);
 
   const int kAccessorProp = kPropCount / 2;
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   for (int i = 0; i < kPropCount; i++) {
     if (i == kAccessorProp) {
       map = expectations.AddAccessorConstant(map, NONE, pair);
     } else {
-      map =
-          expectations.AddDataField(map, NONE, Representation::Smi(), any_type);
+      map = expectations.AddDataField(map, NONE, kMutable,
+                                      Representation::Smi(), any_type);
     }
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
   // 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);
     maps[i] = new_map;
 
-    expectations.SetDataField(i, Representation::Double(), any_type);
+    expectations.SetDataField(i, kMutable, 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());
     CHECK(expectations.Check(*new_map));
   }
 
@@ skipping 17 matching lines @@
 // 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|
 //             |
 //  {} - p0 - p1 - p2A - p3 - p4: |map|
 //
 // where "p2A" and "p2B" differ only in the attributes.
 //
 static void TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
-    Representation from_representation, Handle<FieldType> from_type,
-    Representation to_representation, Handle<FieldType> to_type,
-    Representation expected_representation, Handle<FieldType> expected_type) {
+    const CRFTData& from, const CRFTData& to, const CRFTData& expected) {
   Isolate* isolate = CcTest::i_isolate();
 
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   for (int i = 0; i < kPropCount; i++) {
-    map = expectations.AddDataField(map, NONE, from_representation, from_type);
+    map = expectations.AddDataField(map, NONE, from.constness,
+                                    from.representation, from.type);
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
 
   // Create another branch in transition tree (property at index |kSplitProp|
   // has different attributes), initialize expectations.
   const int kSplitProp = kPropCount / 2;
   Expectations expectations2(isolate);
 
   Handle<Map> map2 = initial_map;
   for (int i = 0; i < kSplitProp; i++) {
-    map2 = expectations2.FollowDataTransition(map2, NONE, from_representation,
-                                              from_type);
+    map2 = expectations2.FollowDataTransition(map2, NONE, from.constness,
+                                              from.representation, from.type);
   }
-  map2 =
-      expectations2.AddDataField(map2, READ_ONLY, to_representation, to_type);
+  map2 = expectations2.AddDataField(map2, READ_ONLY, to.constness,
+                                    to.representation, to.type);
 
   for (int i = kSplitProp + 1; i < kPropCount; i++) {
-    map2 = expectations2.AddDataField(map2, NONE, to_representation, to_type);
+    map2 = expectations2.AddDataField(map2, NONE, to.constness,
+                                      to.representation, to.type);
   }
   CHECK(!map2->is_deprecated());
   CHECK(map2->is_stable());
   CHECK(expectations2.Check(*map2));
 
   Zone zone(isolate->allocator(), ZONE_NAME);
   Handle<Map> field_owner(map->FindFieldOwner(kSplitProp), isolate);
   CompilationDependencies dependencies(isolate, &zone);
   CHECK(!dependencies.HasAborted());
   dependencies.AssumeFieldOwner(field_owner);
 
   // Reconfigure attributes of property |kSplitProp| of |map2| to NONE, which
   // should generalize representations in |map1|.
   Handle<Map> new_map =
       Map::ReconfigureExistingProperty(map2, kSplitProp, kData, NONE);
 
   // |map2| should be left unchanged but marked unstable.
   CHECK(!map2->is_stable());
   CHECK(!map2->is_deprecated());
   CHECK_NE(*map2, *new_map);
   CHECK(expectations2.Check(*map2));
 
   // |map| should be deprecated and |new_map| should match new expectations.
   for (int i = kSplitProp; i < kPropCount; i++) {
-    expectations.SetDataField(i, expected_representation, expected_type);
+    expectations.SetDataField(i, expected.constness, expected.representation,
+                              expected.type);
   }
   CHECK(map->is_deprecated());
   CHECK(!dependencies.HasAborted());
   dependencies.Rollback();  // Properly cleanup compilation info.
   CHECK_NE(*map, *new_map);
 
   CHECK(!new_map->is_deprecated());
   CHECK(expectations.Check(*new_map));
 
   // Update deprecated |map|, it should become |new_map|.
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*new_map, *updated_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|
 //             |
 //  {} - p0 - p1 - p2A - p3 - p4: |map|
 //
 // where "p2A" and "p2B" differ only in the attributes.
 //
 static void TestReconfigureDataFieldAttribute_GeneralizeRepresentationTrivial(
-    Representation from_representation, Handle<FieldType> from_type,
-    Representation to_representation, Handle<FieldType> to_type,
-    Representation expected_representation, Handle<FieldType> expected_type,
+    const CRFTData& from, const CRFTData& to, const CRFTData& expected,
     bool expected_field_type_dependency = true) {
   Isolate* isolate = CcTest::i_isolate();
 
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   for (int i = 0; i < kPropCount; i++) {
-    map = expectations.AddDataField(map, NONE, from_representation, from_type);
+    map = expectations.AddDataField(map, NONE, from.constness,
+                                    from.representation, from.type);
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
 
   // Create another branch in transition tree (property at index |kSplitProp|
   // has different attributes), initialize expectations.
   const int kSplitProp = kPropCount / 2;
   Expectations expectations2(isolate);
 
   Handle<Map> map2 = initial_map;
   for (int i = 0; i < kSplitProp; i++) {
-    map2 = expectations2.FollowDataTransition(map2, NONE, from_representation,
-                                              from_type);
+    map2 = expectations2.FollowDataTransition(map2, NONE, from.constness,
+                                              from.representation, from.type);
   }
-  map2 =
-      expectations2.AddDataField(map2, READ_ONLY, to_representation, to_type);
+  map2 = expectations2.AddDataField(map2, READ_ONLY, to.constness,
+                                    to.representation, to.type);
 
   for (int i = kSplitProp + 1; i < kPropCount; i++) {
-    map2 = expectations2.AddDataField(map2, NONE, to_representation, to_type);
+    map2 = expectations2.AddDataField(map2, NONE, to.constness,
+                                      to.representation, to.type);
   }
   CHECK(!map2->is_deprecated());
   CHECK(map2->is_stable());
   CHECK(expectations2.Check(*map2));
 
   Zone zone(isolate->allocator(), ZONE_NAME);
   Handle<Map> field_owner(map->FindFieldOwner(kSplitProp), isolate);
   CompilationDependencies dependencies(isolate, &zone);
   CHECK(!dependencies.HasAborted());
   dependencies.AssumeFieldOwner(field_owner);
 
   // Reconfigure attributes of property |kSplitProp| of |map2| to NONE, which
   // should generalize representations in |map1|.
   Handle<Map> new_map =
       Map::ReconfigureExistingProperty(map2, kSplitProp, kData, NONE);
 
   // |map2| should be left unchanged but marked unstable.
   CHECK(!map2->is_stable());
   CHECK(!map2->is_deprecated());
   CHECK_NE(*map2, *new_map);
   CHECK(expectations2.Check(*map2));
 
   // In trivial case |map| should be returned as a result of the property
   // reconfiguration, respective field types should be generalized and
   // respective code dependencies should be invalidated. |map| should be NOT
   // deprecated and it should match new expectations.
   for (int i = kSplitProp; i < kPropCount; i++) {
-    expectations.SetDataField(i, expected_representation, expected_type);
+    expectations.SetDataField(i, expected.constness, expected.representation,
+                              expected.type);
   }
   CHECK(!map->is_deprecated());
   CHECK_EQ(*map, *new_map);
   CHECK_EQ(expected_field_type_dependency, dependencies.HasAborted());
   dependencies.Rollback();  // Properly cleanup compilation info.
 
   CHECK(!new_map->is_deprecated());
   CHECK(expectations.Check(*new_map));
 
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*new_map, *updated_map);
 }
 
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationSmiToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
-      Representation::Smi(), any_type, Representation::Double(), any_type,
-      Representation::Double(), any_type);
+      {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::Double(), any_type},
+      {kMutable, Representation::Double(), any_type});
 }
 
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationSmiToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
-      Representation::Smi(), any_type, Representation::HeapObject(), value_type,
-      Representation::Tagged(), any_type);
+      {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationDoubleToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
-      Representation::Double(), any_type, Representation::HeapObject(),
-      value_type, Representation::Tagged(), any_type);
+      {kMutable, Representation::Double(), any_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationHeapObjToHeapObj) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<FieldType> current_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> new_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> expected_type = any_type;
 
   TestReconfigureDataFieldAttribute_GeneralizeRepresentationTrivial(
-      Representation::HeapObject(), current_type, Representation::HeapObject(),
-      new_type, Representation::HeapObject(), expected_type);
+      {kMutable, Representation::HeapObject(), current_type},
+      {kMutable, Representation::HeapObject(), new_type},
+      {kMutable, Representation::HeapObject(), expected_type});
   current_type = expected_type;
 
   new_type = FieldType::Class(Map::Create(isolate, 0), isolate);
 
   TestReconfigureDataFieldAttribute_GeneralizeRepresentationTrivial(
-      Representation::HeapObject(), any_type, Representation::HeapObject(),
-      new_type, Representation::HeapObject(), any_type, false);
+      {kMutable, Representation::HeapObject(), any_type},
+      {kMutable, Representation::HeapObject(), new_type},
+      {kMutable, Representation::HeapObject(), any_type}, false);
 }
 
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeRepresentationHeapObjectToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   TestReconfigureDataFieldAttribute_GeneralizeRepresentation(
-      Representation::HeapObject(), value_type, Representation::Smi(), any_type,
-      Representation::Tagged(), any_type);
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 // Checks that given |map| is deprecated and that it updates to given |new_map|
 // which in turn should match expectations.
 struct CheckDeprecated {
   void Check(Handle<Map> map, Handle<Map> new_map,
              const Expectations& expectations) {
     CHECK(map->is_deprecated());
     CHECK_NE(*map, *new_map);
@@ skipping 79 matching lines @@
     TestConfig& config, Checker& checker) {
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   const int kCustomPropIndex = kPropCount - 2;
   Expectations expectations(isolate);
 
   const int kSplitProp = 2;
   CHECK(kSplitProp < kCustomPropIndex);
 
+  const PropertyConstness constness = kMutable;
   const Representation representation = Representation::Smi();
 
   // Create common part of transition tree.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   for (int i = 0; i < kSplitProp; i++) {
-    map = expectations.AddDataField(map, NONE, representation, any_type);
+    map = expectations.AddDataField(map, NONE, constness, representation,
+                                    any_type);
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
 
   // Create branch to |map1|.
   Handle<Map> map1 = map;
   Expectations expectations1 = expectations;
   for (int i = kSplitProp; i < kCustomPropIndex; i++) {
-    map1 = expectations1.AddDataField(map1, NONE, representation, any_type);
+    map1 = expectations1.AddDataField(map1, NONE, constness, representation,
+                                      any_type);
   }
   map1 = config.AddPropertyAtBranch(1, expectations1, map1);
   for (int i = kCustomPropIndex + 1; i < kPropCount; i++) {
-    map1 = expectations1.AddDataField(map1, NONE, representation, any_type);
+    map1 = expectations1.AddDataField(map1, NONE, constness, representation,
+                                      any_type);
   }
   CHECK(!map1->is_deprecated());
   CHECK(map1->is_stable());
   CHECK(expectations1.Check(*map1));
 
 
   // Create another branch in transition tree (property at index |kSplitProp|
   // has different attributes), initialize expectations.
   Handle<Map> map2 = map;
   Expectations expectations2 = expectations;
-  map2 = expectations2.AddDataField(map2, READ_ONLY, representation, any_type);
+  map2 = expectations2.AddDataField(map2, READ_ONLY, constness, representation,
+                                    any_type);
   for (int i = kSplitProp + 1; i < kCustomPropIndex; i++) {
-    map2 = expectations2.AddDataField(map2, NONE, representation, any_type);
+    map2 = expectations2.AddDataField(map2, NONE, constness, representation,
+                                      any_type);
   }
   map2 = config.AddPropertyAtBranch(2, expectations2, map2);
   for (int i = kCustomPropIndex + 1; i < kPropCount; i++) {
-    map2 = expectations2.AddDataField(map2, NONE, representation, any_type);
+    map2 = expectations2.AddDataField(map2, NONE, constness, representation,
+                                      any_type);
   }
   CHECK(!map2->is_deprecated());
   CHECK(map2->is_stable());
   CHECK(expectations2.Check(*map2));
 
 
   // Reconfigure attributes of property |kSplitProp| of |map2| to NONE, which
   // should generalize representations in |map1|.
   Handle<Map> new_map =
       Map::ReconfigureExistingProperty(map2, kSplitProp, kData, NONE);
@@ skipping 67 matching lines @@
     }
 
     Handle<Map> AddPropertyAtBranch(int branch_id, Expectations& expectations,
                                     Handle<Map> map) {
       CHECK(branch_id == 1 || branch_id == 2);
       Handle<JSFunction> js_func = branch_id == 1 ? js_func1_ : js_func2_;
       return expectations.AddDataConstant(map, NONE, js_func);
     }
 
     void UpdateExpectations(int property_index, Expectations& expectations) {
-      expectations.SetDataField(property_index, Representation::HeapObject(),
-                                function_type_);
+      expectations.SetDataField(property_index, kMutable,
+                                Representation::HeapObject(), function_type_);
     }
   };
 
   TestConfig config;
   // Two branches are "incompatible" so the |map1| should be deprecated.
   CheckDeprecated checker;
   TestReconfigureProperty_CustomPropertyAfterTargetMap(config, checker);
 }
 
 
@@ skipping 109 matching lines @@
     TestConfig() { pair_ = CreateAccessorPair(true, true); }
 
     Handle<Map> AddPropertyAtBranch(int branch_id, Expectations& expectations,
                                     Handle<Map> map) {
       CHECK(branch_id == 1 || branch_id == 2);
       if (branch_id == 1) {
         return expectations.AddAccessorConstant(map, NONE, pair_);
       } else {
         Isolate* isolate = CcTest::i_isolate();
         Handle<FieldType> any_type = FieldType::Any(isolate);
-        return expectations.AddDataField(map, NONE, Representation::Smi(),
-                                         any_type);
+        return expectations.AddDataField(map, NONE, kMutable,
+                                         Representation::Smi(), any_type);
       }
     }
 
     void UpdateExpectations(int property_index, Expectations& expectations) {}
   };
 
   TestConfig config;
   // These are completely separate branches in transition tree.
   CheckUnrelated checker;
   TestReconfigureProperty_CustomPropertyAfterTargetMap(config, checker);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests for elements kind reconfiguration case.
 //
 
 // This test ensures that representation/field type generalization is correctly
 // propagated from one branch of transition tree (|map2) to another (|map|).
 //
 //   + - p0 - p1 - p2A - p3 - p4: |map|
 //   |
 //  ek
 //   |
 //  {} - p0 - p1 - p2B - p3 - p4: |map2|
 //
 // where "p2A" and "p2B" differ only in the representation/field type.
 //
 static void TestReconfigureElementsKind_GeneralizeRepresentation(
-    Representation from_representation, Handle<FieldType> from_type,
-    Representation to_representation, Handle<FieldType> to_type,
-    Representation expected_representation, Handle<FieldType> expected_type) {
+    const CRFTData& from, const CRFTData& to, const CRFTData& expected) {
   Isolate* isolate = CcTest::i_isolate();
 
   Expectations expectations(isolate, FAST_SMI_ELEMENTS);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   initial_map->set_elements_kind(FAST_SMI_ELEMENTS);
 
   Handle<Map> map = initial_map;
   map = expectations.AsElementsKind(map, FAST_ELEMENTS);
   for (int i = 0; i < kPropCount; i++) {
-    map = expectations.AddDataField(map, NONE, from_representation, from_type);
+    map = expectations.AddDataField(map, NONE, from.constness,
+                                    from.representation, from.type);
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
   // Create another branch in transition tree (property at index |kDiffProp|
   // has different representatio/field type), initialize expectations.
   const int kDiffProp = kPropCount / 2;
   Expectations expectations2(isolate, FAST_SMI_ELEMENTS);
 
   Handle<Map> map2 = initial_map;
   for (int i = 0; i < kPropCount; i++) {
     if (i == kDiffProp) {
-      map2 = expectations2.AddDataField(map2, NONE, to_representation, to_type);
+      map2 = expectations2.AddDataField(map2, NONE, to.constness,
+                                        to.representation, to.type);
     } else {
-      map2 = expectations2.AddDataField(map2, NONE, from_representation,
-                                        from_type);
+      map2 = expectations2.AddDataField(map2, NONE, from.constness,
+                                        from.representation, from.type);
     }
   }
   CHECK(!map2->is_deprecated());
   CHECK(map2->is_stable());
   CHECK(expectations2.Check(*map2));
 
   Zone zone(isolate->allocator(), ZONE_NAME);
   Handle<Map> field_owner(map->FindFieldOwner(kDiffProp), isolate);
   CompilationDependencies dependencies(isolate, &zone);
   CHECK(!dependencies.HasAborted());
   dependencies.AssumeFieldOwner(field_owner);
 
   // Reconfigure elements kinds of |map2|, which should generalize
   // representations in |map|.
   Handle<Map> new_map = Map::ReconfigureElementsKind(map2, FAST_ELEMENTS);
 
   // |map2| should be left unchanged but marked unstable.
   CHECK(!map2->is_stable());
   CHECK(!map2->is_deprecated());
   CHECK_NE(*map2, *new_map);
   CHECK(expectations2.Check(*map2));
 
   // |map| should be deprecated and |new_map| should match new expectations.
-  expectations.SetDataField(kDiffProp, expected_representation, expected_type);
+  expectations.SetDataField(kDiffProp, expected.constness,
+                            expected.representation, expected.type);
 
   CHECK(map->is_deprecated());
   CHECK(!dependencies.HasAborted());
   dependencies.Rollback();  // Properly cleanup compilation info.
   CHECK_NE(*map, *new_map);
 
   CHECK(!new_map->is_deprecated());
   CHECK(expectations.Check(*new_map));
 
   // Update deprecated |map|, it should become |new_map|.
@@ skipping 16 matching lines @@
 //
 //   + - p0 - p1 - p2A - p3 - p4: |map|
 //   |
 //  ek
 //   |
 //  {} - p0 - p1 - p2B - p3 - p4: |map2|
 //
 // where "p2A" and "p2B" differ only in the representation/field type.
 //
 static void TestReconfigureElementsKind_GeneralizeRepresentationTrivial(
-    Representation from_representation, Handle<FieldType> from_type,
-    Representation to_representation, Handle<FieldType> to_type,
-    Representation expected_representation, Handle<FieldType> expected_type,
+    const CRFTData& from, const CRFTData& to, const CRFTData& expected,
     bool expected_field_type_dependency = true) {
   Isolate* isolate = CcTest::i_isolate();
 
   Expectations expectations(isolate, FAST_SMI_ELEMENTS);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   initial_map->set_elements_kind(FAST_SMI_ELEMENTS);
 
   Handle<Map> map = initial_map;
   map = expectations.AsElementsKind(map, FAST_ELEMENTS);
   for (int i = 0; i < kPropCount; i++) {
-    map = expectations.AddDataField(map, NONE, from_representation, from_type);
+    map = expectations.AddDataField(map, NONE, from.constness,
+                                    from.representation, from.type);
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
   // Create another branch in transition tree (property at index |kDiffProp|
   // has different attributes), initialize expectations.
   const int kDiffProp = kPropCount / 2;
   Expectations expectations2(isolate, FAST_SMI_ELEMENTS);
 
   Handle<Map> map2 = initial_map;
   for (int i = 0; i < kPropCount; i++) {
     if (i == kDiffProp) {
-      map2 = expectations2.AddDataField(map2, NONE, to_representation, to_type);
+      map2 = expectations2.AddDataField(map2, NONE, to.constness,
+                                        to.representation, to.type);
     } else {
-      map2 = expectations2.AddDataField(map2, NONE, from_representation,
-                                        from_type);
+      map2 = expectations2.AddDataField(map2, NONE, from.constness,
+                                        from.representation, from.type);
     }
   }
   CHECK(!map2->is_deprecated());
   CHECK(map2->is_stable());
   CHECK(expectations2.Check(*map2));
 
   Zone zone(isolate->allocator(), ZONE_NAME);
   Handle<Map> field_owner(map->FindFieldOwner(kDiffProp), isolate);
   CompilationDependencies dependencies(isolate, &zone);
   CHECK(!dependencies.HasAborted());
   dependencies.AssumeFieldOwner(field_owner);
 
   // Reconfigure elements kinds of |map2|, which should generalize
   // representations in |map|.
   Handle<Map> new_map = Map::ReconfigureElementsKind(map2, FAST_ELEMENTS);
 
   // |map2| should be left unchanged but marked unstable.
   CHECK(!map2->is_stable());
   CHECK(!map2->is_deprecated());
   CHECK_NE(*map2, *new_map);
   CHECK(expectations2.Check(*map2));
 
   // In trivial case |map| should be returned as a result of the elements
   // kind reconfiguration, respective field types should be generalized and
   // respective code dependencies should be invalidated. |map| should be NOT
   // deprecated and it should match new expectations.
-  expectations.SetDataField(kDiffProp, expected_representation, expected_type);
+  expectations.SetDataField(kDiffProp, expected.constness,
+                            expected.representation, expected.type);
   CHECK(!map->is_deprecated());
   CHECK_EQ(*map, *new_map);
   CHECK_EQ(expected_field_type_dependency, dependencies.HasAborted());
   dependencies.Rollback();  // Properly cleanup compilation info.
 
   CHECK(!new_map->is_deprecated());
   CHECK(expectations.Check(*new_map));
 
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*new_map, *updated_map);
 
   // Ensure Map::FindElementsKindTransitionedMap() is able to find the
   // transitioned map.
   {
     MapHandleList map_list;
     map_list.Add(updated_map);
     Map* transitioned_map = map2->FindElementsKindTransitionedMap(&map_list);
     CHECK_EQ(*updated_map, transitioned_map);
   }
 }
 
 TEST(ReconfigureElementsKind_GeneralizeRepresentationSmiToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   TestReconfigureElementsKind_GeneralizeRepresentation(
-      Representation::Smi(), any_type, Representation::Double(), any_type,
-      Representation::Double(), any_type);
+      {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::Double(), any_type},
+      {kMutable, Representation::Double(), any_type});
 }
 
 TEST(ReconfigureElementsKind_GeneralizeRepresentationSmiToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   TestReconfigureElementsKind_GeneralizeRepresentation(
-      Representation::Smi(), any_type, Representation::HeapObject(), value_type,
-      Representation::Tagged(), any_type);
+      {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 TEST(ReconfigureElementsKind_GeneralizeRepresentationDoubleToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   TestReconfigureElementsKind_GeneralizeRepresentation(
-      Representation::Double(), any_type, Representation::HeapObject(),
-      value_type, Representation::Tagged(), any_type);
+      {kMutable, Representation::Double(), any_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 TEST(ReconfigureElementsKind_GeneralizeRepresentationHeapObjToHeapObj) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<FieldType> current_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> new_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> expected_type = any_type;
 
   TestReconfigureElementsKind_GeneralizeRepresentationTrivial(
-      Representation::HeapObject(), current_type, Representation::HeapObject(),
-      new_type, Representation::HeapObject(), expected_type);
+      {kMutable, Representation::HeapObject(), current_type},
+      {kMutable, Representation::HeapObject(), new_type},
+      {kMutable, Representation::HeapObject(), expected_type});
   current_type = expected_type;
 
   new_type = FieldType::Class(Map::Create(isolate, 0), isolate);
 
   TestReconfigureElementsKind_GeneralizeRepresentationTrivial(
-      Representation::HeapObject(), any_type, Representation::HeapObject(),
-      new_type, Representation::HeapObject(), any_type, false);
+      {kMutable, Representation::HeapObject(), any_type},
+      {kMutable, Representation::HeapObject(), new_type},
+      {kMutable, Representation::HeapObject(), any_type}, false);
 }
 
 TEST(ReconfigureElementsKind_GeneralizeRepresentationHeapObjectToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   TestReconfigureElementsKind_GeneralizeRepresentation(
-      Representation::HeapObject(), value_type, Representation::Smi(), any_type,
-      Representation::Tagged(), any_type);
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests checking split map deprecation.
 //
 
 TEST(ReconfigurePropertySplitMapTransitionsOverflow) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   for (int i = 0; i < kPropCount; i++) {
-    map = expectations.AddDataField(map, NONE, Representation::Smi(), any_type);
+    map = expectations.AddDataField(map, NONE, kMutable, Representation::Smi(),
+                                    any_type);
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
 
   // Generalize representation of property at index |kSplitProp|.
   const int kSplitProp = kPropCount / 2;
   Handle<Map> split_map;
   Handle<Map> map2 = initial_map;
   {
     for (int i = 0; i < kSplitProp + 1; i++) {
       if (i == kSplitProp) {
         split_map = map2;
       }
 
       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);
-    expectations.SetDataField(kSplitProp, Representation::Double(), any_type);
+    expectations.SetDataField(kSplitProp, kMutable, 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());
   CHECK(map2->is_stable());
   CHECK(!map2->is_deprecated());
 
   // Fill in transition tree of |map2| so that it can't have more transitions.
   for (int i = 0; i < TransitionArray::kMaxNumberOfTransitions; i++) {
     CHECK(TransitionArray::CanHaveMoreTransitions(map2));
     Handle<String> name = MakeName("foo", i);
     Map::CopyWithField(map2, name, any_type, NONE, Representation::Smi(),
                        INSERT_TRANSITION)
         .ToHandleChecked();
   }
   CHECK(!TransitionArray::CanHaveMoreTransitions(map2));
 
   // Try to update |map|, since there is no place for propX transition at |map2|
   // |map| should become "copy-generalized".
   Handle<Map> updated_map = Map::Update(map);
   CHECK(updated_map->GetBackPointer()->IsUndefined(isolate));
 
   for (int i = 0; i < kPropCount; i++) {
-    expectations.SetDataField(i, Representation::Tagged(), any_type);
+    expectations.SetDataField(i, kMutable, Representation::Tagged(), any_type);
   }
   CHECK(expectations.Check(*updated_map));
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests involving special transitions (such as elements kind
 // transition, observed transition or prototype transition).
 //
 
 // This test ensures that representation/field type generalization is correctly
 // propagated from one branch of transition tree (|map2|) to another (|map|).
 //
 //                            p4B: |map2|
 //                             |
 //                             * - special transition
 //                             |
 //  {} - p0 - p1 - p2A - p3 - p4A: |map|
 //
 // where "p4A" and "p4B" are exactly the same properties.
 //
 // TODO(ishell): unify this test template with
 // TestReconfigureDataFieldAttribute_GeneralizeRepresentation once
 // IS_PROTO_TRANS_ISSUE_FIXED and IS_NON_EQUIVALENT_TRANSITION_SUPPORTED are
 // fixed.
 template <typename TestConfig>
 static void TestGeneralizeRepresentationWithSpecialTransition(
-    TestConfig& config, Representation from_representation,
-    Handle<FieldType> from_type, Representation to_representation,
-    Handle<FieldType> to_type, Representation expected_representation,
-    Handle<FieldType> expected_type) {
+    TestConfig& config, const CRFTData& from, const CRFTData& to,
+    const CRFTData& expected) {
   Isolate* isolate = CcTest::i_isolate();
 
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   for (int i = 0; i < kPropCount; i++) {
-    map = expectations.AddDataField(map, NONE, from_representation, from_type);
+    map = expectations.AddDataField(map, NONE, from.constness,
+                                    from.representation, from.type);
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
   Expectations expectations2 = expectations;
 
   // Apply some special transition to |map|.
   CHECK(map->owns_descriptors());
   Handle<Map> map2 = config.Transition(map, expectations2);
 
   // |map| should still match expectations.
   CHECK(!map->is_deprecated());
   CHECK(expectations.Check(*map));
 
   if (config.generalizes_representations()) {
     for (int i = 0; i < kPropCount; i++) {
       expectations2.GeneralizeRepresentation(i);
     }
   }
 
   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);
+                                                   to.representation, to.type);
     maps[i] = new_map;
 
-    expectations.SetDataField(i, expected_representation, expected_type);
+    expectations.SetDataField(i, expected.constness, 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);
     CHECK(!new_map2->is_deprecated());
     CHECK(!new_map2->is_dictionary_map());
 
@@ skipping 45 matching lines @@
       expectations.SetElementsKind(DICTIONARY_ELEMENTS);
       return Map::CopyForPreventExtensions(map, NONE, frozen_symbol,
                                            "CopyForPreventExtensions");
     }
     // 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);
+      config, {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(ElementsKindTransitionFromMapNotOwningDescriptor) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
@@ skipping 15 matching lines @@
       expectations.SetElementsKind(DICTIONARY_ELEMENTS);
       return Map::CopyForPreventExtensions(map, NONE, frozen_symbol,
                                            "CopyForPreventExtensions");
     }
     // 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);
+      config, {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(PrototypeTransitionFromMapOwningDescriptor) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
 
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
@@ skipping 12 matching lines @@
       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);
+      config, {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 TEST(PrototypeTransitionFromMapNotOwningDescriptor) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
 
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
@@ skipping 23 matching lines @@
       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);
+      config, {kMutable, Representation::Smi(), any_type},
+      {kMutable, Representation::HeapObject(), value_type},
+      {kMutable, Representation::Tagged(), any_type});
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests for higher level transitioning mechanics.
 //
 
 struct TransitionToDataFieldOperator {
+  PropertyConstness constness_;
   Representation representation_;
   PropertyAttributes attributes_;
   Handle<FieldType> heap_type_;
   Handle<Object> value_;
 
-  TransitionToDataFieldOperator(Representation representation,
+  TransitionToDataFieldOperator(PropertyConstness constness,
+                                Representation representation,
                                 Handle<FieldType> heap_type,
                                 Handle<Object> value,
                                 PropertyAttributes attributes = NONE)
-      : representation_(representation),
+      : constness_(constness),
+        representation_(representation),
         attributes_(attributes),
         heap_type_(heap_type),
         value_(value) {}
 
   Handle<Map> DoTransition(Expectations& expectations, Handle<Map> map) {
-    return expectations.TransitionToDataField(map, attributes_, representation_,
-                                              heap_type_, value_);
+    return expectations.TransitionToDataField(
+        map, attributes_, constness_, representation_, heap_type_, value_);
   }
 };
 
 
 struct TransitionToDataConstantOperator {
   PropertyAttributes attributes_;
   Handle<JSFunction> value_;
 
   TransitionToDataConstantOperator(Handle<JSFunction> value,
                                    PropertyAttributes attributes = NONE)
@@ skipping 28 matching lines @@
   ReconfigureAsDataPropertyOperator(int descriptor,
                                     Representation representation,
                                     Handle<FieldType> heap_type,
                                     PropertyAttributes attributes = NONE)
       : descriptor_(descriptor),
         representation_(representation),
         attributes_(attributes),
         heap_type_(heap_type) {}
 
   Handle<Map> DoTransition(Expectations& expectations, Handle<Map> map) {
-    expectations.SetDataField(descriptor_, representation_, heap_type_);
+    expectations.SetDataField(descriptor_, kMutable, representation_,
+                              heap_type_);
     return Map::ReconfigureExistingProperty(map, descriptor_, kData,
                                             attributes_);
   }
 };
 
 
 struct ReconfigureAsAccessorPropertyOperator {
   int descriptor_;
   PropertyAttributes attributes_;
 
   ReconfigureAsAccessorPropertyOperator(int descriptor,
                                         PropertyAttributes attributes = NONE)
       : descriptor_(descriptor), attributes_(attributes) {}
 
   Handle<Map> DoTransition(Expectations& expectations, Handle<Map> map) {
     expectations.SetAccessorField(descriptor_);
     return Map::ReconfigureExistingProperty(map, descriptor_, kAccessor,
                                             attributes_);
   }
 };
 
 
 // Checks that representation/field type generalization happened.
 struct FieldGeneralizationChecker {
   int descriptor_;
+  PropertyConstness constness_;
   Representation representation_;
   PropertyAttributes attributes_;
   Handle<FieldType> heap_type_;
 
-  FieldGeneralizationChecker(int descriptor, Representation representation,
+  FieldGeneralizationChecker(int descriptor, PropertyConstness constness,
+                             Representation representation,
                              Handle<FieldType> heap_type,
                              PropertyAttributes attributes = NONE)
       : descriptor_(descriptor),
+        constness_(constness),
         representation_(representation),
         attributes_(attributes),
         heap_type_(heap_type) {}
 
   void Check(Expectations& expectations2, Handle<Map> map1, Handle<Map> map2) {
     CHECK(!map2->is_deprecated());
 
     CHECK(map1->is_deprecated());
     CHECK_NE(*map1, *map2);
     Handle<Map> updated_map = Map::Update(map1);
     CHECK_EQ(*map2, *updated_map);
 
-    expectations2.SetDataField(descriptor_, attributes_, representation_,
-                               heap_type_);
+    expectations2.SetDataField(descriptor_, attributes_, constness_,
+                               representation_, heap_type_);
     CHECK(expectations2.Check(*map2));
   }
 };
 
 
 // Checks that existing transition was taken as is.
 struct SameMapChecker {
   void Check(Expectations& expectations, Handle<Map> map1, Handle<Map> map2) {
     CHECK(!map2->is_deprecated());
     CHECK_EQ(*map1, *map2);
@@ skipping 34 matching lines @@
                              TransitionOp2& transition_op2, Checker& checker) {
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Expectations expectations(isolate);
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   for (int i = 0; i < kPropCount - 1; i++) {
-    map = expectations.AddDataField(map, NONE, Representation::Smi(), any_type);
+    map = expectations.AddDataField(map, NONE, kMutable, Representation::Smi(),
+                                    any_type);
   }
   CHECK(expectations.Check(*map));
 
   Expectations expectations1 = expectations;
   Handle<Map> map1 = transition_op1.DoTransition(expectations1, map);
   CHECK(expectations1.Check(*map1));
 
   Expectations expectations2 = expectations;
   Handle<Map> map2 = transition_op2.DoTransition(expectations2, map);
 
   // Let the test customization do the check.
   checker.Check(expectations2, map1, map2);
 }
 
 
 TEST(TransitionDataFieldToDataField) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<Object> value1 = handle(Smi::kZero, isolate);
-  TransitionToDataFieldOperator transition_op1(Representation::Smi(), any_type,
-                                               value1);
+  TransitionToDataFieldOperator transition_op1(kMutable, Representation::Smi(),
+                                               any_type, value1);
 
   Handle<Object> value2 = isolate->factory()->NewHeapNumber(0);
-  TransitionToDataFieldOperator transition_op2(Representation::Double(),
-                                               any_type, value2);
+  TransitionToDataFieldOperator transition_op2(
+      kMutable, Representation::Double(), any_type, value2);
 
-  FieldGeneralizationChecker checker(kPropCount - 1, Representation::Double(),
-                                     any_type);
+  FieldGeneralizationChecker checker(kPropCount - 1, kMutable,
+                                     Representation::Double(), any_type);
   TestTransitionTo(transition_op1, transition_op2, checker);
 }
 
 
 TEST(TransitionDataConstantToSameDataConstant) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
 
@@ skipping 20 matching lines @@
 
   Handle<JSFunction> js_func1 =
       factory->NewFunction(sloppy_map, info, isolate->native_context());
   TransitionToDataConstantOperator transition_op1(js_func1);
 
   Handle<JSFunction> js_func2 =
       factory->NewFunction(sloppy_map, info, isolate->native_context());
   TransitionToDataConstantOperator transition_op2(js_func2);
 
   FieldGeneralizationChecker checker(
-      kPropCount - 1, Representation::HeapObject(), function_type);
+      kPropCount - 1, kMutable, Representation::HeapObject(), function_type);
   TestTransitionTo(transition_op1, transition_op2, checker);
 }
 
 
 TEST(TransitionDataConstantToDataField) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<JSFunction> js_func1 = factory->NewFunction(factory->empty_string());
   TransitionToDataConstantOperator transition_op1(js_func1);
 
   Handle<Object> value2 = isolate->factory()->NewHeapNumber(0);
-  TransitionToDataFieldOperator transition_op2(Representation::Double(),
-                                               any_type, value2);
+  TransitionToDataFieldOperator transition_op2(
+      kMutable, Representation::Double(), any_type, value2);
 
-  FieldGeneralizationChecker checker(kPropCount - 1, Representation::Tagged(),
-                                     any_type);
+  FieldGeneralizationChecker checker(kPropCount - 1, kMutable,
+                                     Representation::Tagged(), any_type);
   TestTransitionTo(transition_op1, transition_op2, checker);
 }
 
 
 TEST(TransitionAccessorConstantToSameAccessorConstant) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   Handle<AccessorPair> pair = CreateAccessorPair(true, true);
   TransitionToAccessorConstantOperator transition_op(pair);
 
   SameMapChecker checker;
   TestTransitionTo(transition_op, transition_op, checker);
 }
 
 TEST(FieldTypeConvertSimple) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   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)