[vm] Prepare for enhanced enums

This change prepares VM for enhanced enums language feature.
List of enum values is now queried using 'values' static field
and not inferred from the list of fields (as enhanced enums allow
arbitrary fields).

TEST=ci

Issue: #47861
Change-Id: Id6eabb6c4ac5a5f03b22ceb67d57431082e22576
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/225020
Reviewed-by: Ryan Macnak <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>

Author: alexmarkov

runtime/vm/class_finalizer.cc

@@ -1133,7 +1133,7 @@ void ClassFinalizer::FinalizeClass(const Class& cls) {
   }
   FinalizeMemberTypes(cls);
 
-  if (cls.is_enum_class()) {
+  if (cls.is_enum_class() && !FLAG_precompiled_mode) {
     AllocateEnumValues(cls);
   }
 
@@ -1216,69 +1216,58 @@ ErrorPtr ClassFinalizer::LoadClassMembers(const Class& cls) {
   }
 }
 
-// Allocate instances for each enumeration value, and populate the
-// static field 'values'.
-// By allocating the instances programmatically, we save an implicit final
-// getter function object for each enumeration value and for the
-// values field. We also don't have to generate the code for these getters
-// from thin air (no source code is available).
+// Eagerly allocate instances for enumeration values by evaluating
+// static const field 'values'. Also, pre-allocate
+// deleted sentinel value. This is needed to correctly
+// migrate enumeration values in case of hot reload.
 void ClassFinalizer::AllocateEnumValues(const Class& enum_cls) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
 
+  const auto& values_field =
+      Field::Handle(zone, enum_cls.LookupStaticField(Symbols::Values()));
+  ASSERT(!values_field.IsNull() && values_field.is_static() &&
+         values_field.is_const());
+
+  const auto& values =
+      Object::Handle(zone, values_field.StaticConstFieldValue());
+  if (values.IsError()) {
+    ReportError(Error::Cast(values));
+  }
+  ASSERT(values.IsArray());
+
   // The enum_cls is the actual declared class.
   // The shared super-class holds the fields for index and name.
-  const Class& super_cls = Class::Handle(zone, enum_cls.SuperClass());
+  const auto& super_cls = Class::Handle(zone, enum_cls.SuperClass());
 
-  const Field& index_field =
+  const auto& index_field =
       Field::Handle(zone, super_cls.LookupInstanceField(Symbols::Index()));
   ASSERT(!index_field.IsNull());
 
-  const Field& name_field = Field::Handle(
+  const auto& name_field = Field::Handle(
       zone, super_cls.LookupInstanceFieldAllowPrivate(Symbols::_name()));
   ASSERT(!name_field.IsNull());
 
-  const String& enum_name = String::Handle(zone, enum_cls.ScrubbedName());
-
-  const Array& fields = Array::Handle(zone, enum_cls.fields());
-  Field& field = Field::Handle(zone);
-  Instance& enum_value = Instance::Handle(zone);
-  String& enum_ident = String::Handle(zone);
-
-  enum_ident =
-      Symbols::FromConcat(thread, Symbols::_DeletedEnumPrefix(), enum_name);
-  enum_value = Instance::New(enum_cls, Heap::kOld);
-  enum_value.SetField(index_field, Smi::Handle(zone, Smi::New(-1)));
-  enum_value.SetField(name_field, enum_ident);
-  enum_value = enum_value.Canonicalize(thread);
-  ASSERT(!enum_value.IsNull());
-  ASSERT(enum_value.IsCanonical());
-  const Field& sentinel = Field::Handle(
+  const auto& enum_name = String::Handle(zone, enum_cls.ScrubbedName());
+
+  const auto& sentinel_ident = String::Handle(
+      zone,
+      Symbols::FromConcat(thread, Symbols::_DeletedEnumPrefix(), enum_name));
+  auto& sentinel_value =
+      Instance::Handle(zone, Instance::New(enum_cls, Heap::kOld));
+  sentinel_value.SetField(index_field, Smi::Handle(zone, Smi::New(-1)));
+  sentinel_value.SetField(name_field, sentinel_ident);
+  sentinel_value = sentinel_value.Canonicalize(thread);
+  ASSERT(!sentinel_value.IsNull());
+  ASSERT(sentinel_value.IsCanonical());
+  const auto& sentinel_field = Field::Handle(
       zone, enum_cls.LookupStaticField(Symbols::_DeletedEnumSentinel()));
-  ASSERT(!sentinel.IsNull());
+  ASSERT(!sentinel_field.IsNull());
 
   // The static const field contains `Object::null()` instead of
   // `Object::sentinel()` - so it's not considered an initializing store.
-  sentinel.SetStaticConstFieldValue(enum_value,
-                                    /*assert_initializing_store*/ false);
-
-  ASSERT(enum_cls.kernel_offset() > 0);
-  Object& error = Error::Handle(zone);
-  for (intptr_t i = 0; i < fields.Length(); i++) {
-    field = Field::RawCast(fields.At(i));
-    if (!field.is_static() || !field.is_const() ||
-        (sentinel.ptr() == field.ptr())) {
-      continue;
-    }
-    // Hot-reload expects the static const fields to be evaluated when
-    // performing a reload.
-    if (!FLAG_precompiled_mode) {
-      error = field.StaticConstFieldValue();
-      if (error.IsError()) {
-        ReportError(Error::Cast(error));
-      }
-    }
-  }
+  sentinel_field.SetStaticConstFieldValue(sentinel_value,
+                                          /*assert_initializing_store*/ false);
 }
 
 void ClassFinalizer::PrintClassInformation(const Class& cls) {

runtime/vm/compiler/aot/precompiler.cc

@@ -2455,11 +2455,6 @@ void Precompiler::TraceTypesFromRetainedClasses() {
       if (cls.is_allocated()) {
         retain = true;
       }
-      if (cls.is_enum_class()) {
-        // Enum classes have live instances, so we cannot unregister
-        // them.
-        retain = true;
-      }
 
       constants = cls.constants();
       retained_constants = GrowableObjectArray::New();

runtime/vm/isolate_reload.cc

@@ -1556,9 +1556,8 @@ void ProgramReloadContext::CommitBeforeInstanceMorphing() {
           ASSERT(new_cls.is_enum_class() == old_cls.is_enum_class());
           if (new_cls.is_enum_class() && new_cls.is_finalized()) {
             new_cls.ReplaceEnum(this, old_cls);
-          } else {
-            new_cls.CopyStaticFieldValues(this, old_cls);
           }
+          new_cls.CopyStaticFieldValues(this, old_cls);
           old_cls.PatchFieldsAndFunctions();
           old_cls.MigrateImplicitStaticClosures(this, new_cls);
         }

runtime/vm/object_reload.cc

@@ -192,9 +192,6 @@ void CallSiteResetter::ResetCaches(const ObjectPool& pool) {
 
 void Class::CopyStaticFieldValues(ProgramReloadContext* reload_context,
                                   const Class& old_cls) const {
-  // We only update values for non-enum classes.
-  const bool update_values = !is_enum_class();
-
   const Array& old_field_list = Array::Handle(old_cls.fields());
   Field& old_field = Field::Handle();
   String& old_name = String::Handle();
@@ -215,7 +212,7 @@ void Class::CopyStaticFieldValues(ProgramReloadContext* reload_context,
         if (field.is_static()) {
           // We only copy values if requested and if the field is not a const
           // field. We let const fields be updated with a reload.
-          if (update_values && !field.is_const()) {
+          if (!field.is_const()) {
             // Make new field point to the old field value so that both
             // old and new code see and update same value.
             reload_context->isolate_group()->FreeStaticField(field);
@@ -307,15 +304,15 @@ void Class::ReplaceEnum(ProgramReloadContext* reload_context,
 
   Zone* zone = Thread::Current()->zone();
 
-  Array& enum_fields = Array::Handle(zone);
   Field& field = Field::Handle(zone);
+  Class& cls = Class::Handle(zone);
   String& enum_ident = String::Handle();
   Instance& old_enum_value = Instance::Handle(zone);
   Instance& enum_value = Instance::Handle(zone);
   // The E.values array.
-  Instance& old_enum_values = Instance::Handle(zone);
+  Array& old_enum_values = Array::Handle(zone);
   // The E.values array.
-  Instance& enum_values = Instance::Handle(zone);
+  Array& enum_values = Array::Handle(zone);
   // The E._deleted_enum_sentinel instance.
   Instance& old_deleted_enum_sentinel = Instance::Handle(zone);
   // The E._deleted_enum_sentinel instance.
@@ -327,31 +324,26 @@ void Class::ReplaceEnum(ProgramReloadContext* reload_context,
   TIR_Print("Replacing enum `%s`\n", String::Handle(Name()).ToCString());
 
   {
+    field = old_enum.LookupStaticField(Symbols::Values());
+    ASSERT(!field.IsNull() && field.is_static() && field.is_const());
+    old_enum_values ^= field.StaticConstFieldValue();
+    ASSERT(!old_enum_values.IsNull());
+
+    field = old_enum.LookupStaticField(Symbols::_DeletedEnumSentinel());
+    ASSERT(!field.IsNull() && field.is_static() && field.is_const());
+    old_deleted_enum_sentinel ^= field.StaticConstFieldValue();
+    ASSERT(!old_deleted_enum_sentinel.IsNull());
+
+    cls = old_enum.SuperClass();
+    field = cls.LookupInstanceFieldAllowPrivate(Symbols::_name());
+    ASSERT(!field.IsNull());
+
     UnorderedHashMap<EnumMapTraits> enum_map(enum_map_storage.ptr());
     // Build a map of all enum name -> old enum instance.
-    enum_fields = old_enum.fields();
-    for (intptr_t i = 0; i < enum_fields.Length(); i++) {
-      field = Field::RawCast(enum_fields.At(i));
-      enum_ident = field.name();
-      if (!field.is_static()) {
-        // Enum instances are only held in static fields.
-        continue;
-      }
-      ASSERT(field.is_const());
-      if (enum_ident.Equals(Symbols::Values())) {
-        old_enum_values = Instance::RawCast(field.StaticConstFieldValue());
-        // Non-enum instance.
-        continue;
-      }
-      if (enum_ident.Equals(Symbols::_DeletedEnumSentinel())) {
-        old_deleted_enum_sentinel =
-            Instance::RawCast(field.StaticConstFieldValue());
-        // Non-enum instance.
-        continue;
-      }
-      old_enum_value = Instance::RawCast(field.StaticConstFieldValue());
-
+    for (intptr_t i = 0, n = old_enum_values.Length(); i < n; ++i) {
+      old_enum_value ^= old_enum_values.At(i);
       ASSERT(!old_enum_value.IsNull());
+      enum_ident ^= old_enum_value.GetField(field);
       VTIR_Print("Element %s being added to mapping\n", enum_ident.ToCString());
       bool update = enum_map.UpdateOrInsert(enum_ident, old_enum_value);
       VTIR_Print("Element %s added to mapping\n", enum_ident.ToCString());
@@ -364,31 +356,27 @@ void Class::ReplaceEnum(ProgramReloadContext* reload_context,
 
   bool enums_deleted = false;
   {
+    field = LookupStaticField(Symbols::Values());
+    ASSERT(!field.IsNull() && field.is_static() && field.is_const());
+    enum_values ^= field.StaticConstFieldValue();
+    ASSERT(!enum_values.IsNull());
+
+    field = LookupStaticField(Symbols::_DeletedEnumSentinel());
+    ASSERT(!field.IsNull() && field.is_static() && field.is_const());
+    deleted_enum_sentinel ^= field.StaticConstFieldValue();
+    ASSERT(!deleted_enum_sentinel.IsNull());
+
+    cls = SuperClass();
+    field = cls.LookupInstanceFieldAllowPrivate(Symbols::_name());
+    ASSERT(!field.IsNull());
+
     UnorderedHashMap<EnumMapTraits> enum_map(enum_map_storage.ptr());
     // Add a become mapping from the old instances to the new instances.
-    enum_fields = fields();
-    for (intptr_t i = 0; i < enum_fields.Length(); i++) {
-      field = Field::RawCast(enum_fields.At(i));
-      enum_ident = field.name();
-      if (!field.is_static()) {
-        // Enum instances are only held in static fields.
-        continue;
-      }
-      ASSERT(field.is_const());
-      if (enum_ident.Equals(Symbols::Values())) {
-        enum_values = Instance::RawCast(field.StaticConstFieldValue());
-        // Non-enum instance.
-        continue;
-      }
-      if (enum_ident.Equals(Symbols::_DeletedEnumSentinel())) {
-        deleted_enum_sentinel =
-            Instance::RawCast(field.StaticConstFieldValue());
-        // Non-enum instance.
-        continue;
-      }
-      enum_value = Instance::RawCast(field.StaticConstFieldValue());
-
+    for (intptr_t i = 0, n = enum_values.Length(); i < n; ++i) {
+      enum_value ^= enum_values.At(i);
       ASSERT(!enum_value.IsNull());
+      enum_ident ^= enum_value.GetField(field);
+
       old_enum_value ^= enum_map.GetOrNull(enum_ident);
       if (old_enum_value.IsNull()) {
         VTIR_Print("New element %s was not found in mapping\n",
@@ -408,13 +396,9 @@ void Class::ReplaceEnum(ProgramReloadContext* reload_context,
   }
 
   // Map the old E.values array to the new E.values array.
-  ASSERT(!old_enum_values.IsNull());
-  ASSERT(!enum_values.IsNull());
   reload_context->AddBecomeMapping(old_enum_values, enum_values);
 
   // Map the old E._deleted_enum_sentinel to the new E._deleted_enum_sentinel.
-  ASSERT(!old_deleted_enum_sentinel.IsNull());
-  ASSERT(!deleted_enum_sentinel.IsNull());
   reload_context->AddBecomeMapping(old_deleted_enum_sentinel,
                                    deleted_enum_sentinel);