[runtime] Remove PropertyType definition and use PropertyKind/PropertyLocation instead.

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 55 matching lines @@
     pair->set_getter(*func);
   }
   if (with_setter) {
     Handle<JSFunction> func = factory->NewFunction(empty_string);
     pair->set_setter(*func);
   }
   return pair;
 }
 
 
-static bool EqualDetails(DescriptorArray* descriptors, int descriptor,
-                         PropertyType type, PropertyAttributes attributes,
-                         Representation representation, int field_index = -1) {
-  PropertyDetails details = descriptors->GetDetails(descriptor);
-  if (details.type() != type) return false;
-  if (details.attributes() != attributes) return false;
-  if (!details.representation().Equals(representation)) return false;
-  if (field_index >= 0 && details.field_index() != field_index) return false;
-  return true;
-}
-
-
 class Expectations {
   static const int MAX_PROPERTIES = 10;
   Isolate* isolate_;
   ElementsKind elements_kind_;
-  PropertyType types_[MAX_PROPERTIES];
+  PropertyKind kinds_[MAX_PROPERTIES];
+  PropertyLocation locations_[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, PropertyType type, PropertyAttributes attributes,
-            Representation representation, Handle<Object> value) {
+  void Init(int index, PropertyKind kind, PropertyAttributes attributes,
+            PropertyLocation location, Representation representation,
+            Handle<Object> value) {
     CHECK(index < MAX_PROPERTIES);
-    types_[index] = type;
+    kinds_[index] = kind;
+    locations_[index] = location;
     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 (types_[i] == ACCESSOR_CONSTANT) {
+
+      if (kinds_[i] == kData) {
+        os << Brief(*values_[i]);
+      } else {
+        // kAccessor
         os << "(get: " << Brief(*values_[i])
            << ", set: " << Brief(*setter_values_[i]) << ") ";
+      }
+
+      os << " (";
+      os << (kinds_[i] == kData ? "data " : "accessor ");
+      if (locations_[i] == kField) {
+        os << "field"
+           << ": " << representations_[i].Mnemonic();
       } else {
-        os << Brief(*values_[i]);
+        os << "descriptor";
       }
-      os << " (";
-      switch (types_[i]) {
-        case DATA_CONSTANT:
-          os << "immutable ";
-        // Fall through.
-        case DATA:
-          os << "data";
-          break;
-
-        case ACCESSOR_CONSTANT:
-          os << "immutable ";
-        // Fall through.
-        case ACCESSOR:
-          os << "accessor";
-          break;
-      }
-      os << ": " << representations_[i].Mnemonic();
       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(types_[index] == DATA || types_[index] == ACCESSOR);
+    CHECK_EQ(kField, locations_[index]);
     return Handle<FieldType>::cast(values_[index]);
   }
 
   void SetDataField(int index, PropertyAttributes attrs,
-                    Representation representation, Handle<FieldType> value) {
-    Init(index, DATA, attrs, representation, value);
+                    Representation representation,
+                    Handle<FieldType> field_type) {
+    Init(index, kData, attrs, kField, representation, field_type);
   }
 
   void SetDataField(int index, Representation representation,
-                    Handle<FieldType> value) {
-    SetDataField(index, attributes_[index], representation, value);
+                    Handle<FieldType> field_type) {
+    SetDataField(index, attributes_[index], representation, field_type);
   }
 
   void SetAccessorField(int index, PropertyAttributes attrs) {
-    Init(index, ACCESSOR, attrs, Representation::Tagged(),
+    Init(index, kAccessor, attrs, 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, DATA_CONSTANT, attrs, Representation::HeapObject(), value);
+    Init(index, kData, attrs, 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, ACCESSOR_CONSTANT, attrs, Representation::Tagged(), getter);
+    Init(index, kAccessor, attrs, kDescriptor, Representation::Tagged(),
+         getter);
     setter_values_[index] = setter;
   }
 
   void SetAccessorConstantComponent(int index, PropertyAttributes attrs,
                                     AccessorComponent component,
                                     Handle<Object> accessor) {
-    CHECK_EQ(ACCESSOR_CONSTANT, types_[index]);
+    CHECK_EQ(kAccessor, kinds_[index]);
+    CHECK_EQ(kDescriptor, locations_[index]);
     CHECK(index < number_of_properties_);
     if (component == ACCESSOR_GETTER) {
       values_[index] = accessor;
     } else {
       setter_values_[index] = accessor;
     }
   }
 
   void SetAccessorConstant(int index, PropertyAttributes attrs,
                            Handle<AccessorPair> pair) {
     Handle<Object> getter = handle(pair->getter(), isolate_);
     Handle<Object> setter = handle(pair->setter(), isolate_);
     SetAccessorConstant(index, attrs, getter, setter);
   }
 
   void SetAccessorConstant(int index, Handle<Object> getter,
                            Handle<Object> setter) {
     SetAccessorConstant(index, attributes_[index], getter, setter);
   }
 
   void SetAccessorConstant(int index, Handle<AccessorPair> pair) {
     Handle<Object> getter = handle(pair->getter(), isolate_);
     Handle<Object> setter = handle(pair->setter(), isolate_);
     SetAccessorConstant(index, getter, setter);
   }
 
   void GeneralizeRepresentation(int index) {
     CHECK(index < number_of_properties_);
     representations_[index] = Representation::Tagged();
-    if (types_[index] == DATA || types_[index] == ACCESSOR) {
+    if (locations_[index] == kField) {
       values_[index] = FieldType::Any(isolate_);
     }
   }
 
 
   bool Check(DescriptorArray* descriptors, int descriptor) const {
-    PropertyType type = types_[descriptor];
-    if (!EqualDetails(descriptors, descriptor, type, attributes_[descriptor],
-                      representations_[descriptor])) {
-      return false;
-    }
+    PropertyDetails details = descriptors->GetDetails(descriptor);
+
+    if (details.kind() != kinds_[descriptor]) return false;
+    if (details.location() != locations_[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];
-    switch (type) {
-      case DATA:
-      case ACCESSOR: {
+    if (details.location() == kField) {
+      if (details.kind() == kData) {
         FieldType* type = descriptors->GetFieldType(descriptor);
         return FieldType::cast(expected_value) == type;
+      } else {
+        // kAccessor
+        UNREACHABLE();
+        return false;
       }
-
-      case DATA_CONSTANT:
+    } else {
+      // kDescriptor
+      if (details.kind() == kData) {
         return value == expected_value;
-
-      case ACCESSOR_CONSTANT: {
+      } else {
+        // kAccessor
         if (value == expected_value) return true;
         if (!value->IsAccessorPair()) return false;
         AccessorPair* pair = AccessorPair::cast(value);
         return pair->Equals(expected_value, *setter_values_[descriptor]);
       }
     }
     UNREACHABLE();
     return false;
   }
 
@@ skipping 2165 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)