[runtime] Use PropertyKind/PropertyLocation instead of PropertyType.

src/map-updater.cc

 // Copyright 2017 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 "src/map-updater.h"
 
 #include "src/field-type.h"
 #include "src/handles.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
 #include "src/objects.h"
 #include "src/transitions.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
 inline bool EqualImmutableValues(Object* obj1, Object* obj2) {
   if (obj1 == obj2) return true;  // Valid for both kData and kAccessor kinds.
   // TODO(ishell): compare AccessorPairs.
   return false;
 }
 
+inline bool LocationFitsInto(PropertyLocation what, PropertyLocation where) {
+  return where == kField || what == kDescriptor;
+}
+
 }  // namespace
 
 Name* MapUpdater::GetKey(int descriptor) const {
   return old_descriptors_->GetKey(descriptor);
 }
 
 PropertyDetails MapUpdater::GetDetails(int descriptor) const {
   DCHECK_LE(0, descriptor);
   if (descriptor == modified_descriptor_) {
     return PropertyDetails(new_kind_, new_attributes_, new_location_,
@@ skipping 234 matching lines @@
     // Check if target map is incompatible.
     PropertyDetails tmp_details = tmp_descriptors->GetDetails(i);
     DCHECK_EQ(old_details.kind(), tmp_details.kind());
     DCHECK_EQ(old_details.attributes(), tmp_details.attributes());
     if (old_details.kind() == kAccessor &&
         !EqualImmutableValues(GetValue(i), tmp_descriptors->GetValue(i))) {
       // TODO(ishell): mutable accessors are not implemented yet.
       return CopyGeneralizeAllRepresentations("GenAll_Incompatible");
     }
     // Check if old location fits into tmp location.
-    if (old_details.location() == kField &&
-        tmp_details.location() == kDescriptor) {
+    if (!LocationFitsInto(old_details.location(), tmp_details.location())) {
       break;
     }
 
     // Check if old representation fits into tmp representation.
     Representation tmp_representation = tmp_details.representation();
     if (!old_details.representation().fits_into(tmp_representation)) {
       break;
     }
 
     if (tmp_details.location() == kField) {
@@ skipping 275 matching lines @@
 
   if (FLAG_trace_generalization && modified_descriptor_ >= 0) {
     PropertyDetails old_details =
         old_descriptors_->GetDetails(modified_descriptor_);
     PropertyDetails new_details =
         new_descriptors->GetDetails(modified_descriptor_);
     MaybeHandle<FieldType> old_field_type;
     MaybeHandle<FieldType> new_field_type;
     MaybeHandle<Object> old_value;
     MaybeHandle<Object> new_value;
-    if (old_details.type() == DATA) {
+    if (old_details.location() == kField) {
       old_field_type = handle(
           old_descriptors_->GetFieldType(modified_descriptor_), isolate_);
     } else {
       old_value =
           handle(old_descriptors_->GetValue(modified_descriptor_), isolate_);
     }
-    if (new_details.type() == DATA) {
+    if (new_details.location() == kField) {
       new_field_type =
           handle(new_descriptors->GetFieldType(modified_descriptor_), isolate_);
     } else {
       new_value =
           handle(new_descriptors->GetValue(modified_descriptor_), isolate_);
     }
 
     old_map_->PrintGeneralization(
         stdout, "", modified_descriptor_, split_nof, old_nof_,
         old_details.location() == kDescriptor && new_location_ == kField,
@@ skipping 12 matching lines @@
   // the new descriptors to maintain descriptors sharing invariant.
   split_map->ReplaceDescriptors(*new_descriptors, *new_layout_descriptor);
 
   result_map_ = new_map;
   state_ = kEnd;
   return state_;  // Done.
 }
 
 }  // namespace internal
 }  // namespace v8