Map deleted enum values to a sentinel value.

runtime/vm/object_reload.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/object.h"
 
 #include "vm/hash_table.h"
 #include "vm/isolate_reload.h"
 #include "vm/log.h"
 #include "vm/resolver.h"
@@ skipping 186 matching lines @@
 // When an enum is reloaded the following three things can happen, possibly
 // simultaneously.
 //
 // 1) A new enum value is added.
 //   This case is handled automatically.
 // 2) Enum values are reordered.
 //   We pair old and new enums and the old enums 'become' the new ones so
 //   the ordering is always correct (i.e. enum indicies match slots in values
 //   array)
 // 3) An existing enum value is removed.
-//   We leave old enum values that have no mapping to the reloaded class
-//   in the heap. This means that if a programmer does the following:
-//   enum Foo { A, B }; var x = Foo.A;
-//   *reload*
-//   enum Foo { B };
-//   *reload*
-//   enum Foo { A, B }; expect(identical(x, Foo.A));
-//   The program will fail because we were not able to pair Foo.A on the second
-//   reload.
+//   Each enum class has a canonical 'deleted' enum sentinel instance.
+//   When an enum value is deleted, we 'become' all references to the 'deleted'
+//   sentinel value. The index value is -1.
 //
-//   Deleted enum values still in the heap continue to function but their
-//   index field will not be valid.
 void Class::ReplaceEnum(const Class& old_enum) const {
   // We only do this for finalized enum classes.
   ASSERT(is_enum_class());
   ASSERT(old_enum.is_enum_class());
   ASSERT(is_finalized());
   ASSERT(old_enum.is_finalized());
 
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   IsolateReloadContext* reload_context = Isolate::Current()->reload_context();
   ASSERT(reload_context != NULL);
 
   Array& enum_fields = Array::Handle(zone);
   Field& field = Field::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);
   // The E.values array.
   Instance& enum_values = Instance::Handle(zone);
+  // The E._deleted_enum_sentinel instance.
+  Instance& old_deleted_enum_sentinel = Instance::Handle(zone);
+  // The E._deleted_enum_sentinel instance.
+  Instance& deleted_enum_sentinel = Instance::Handle(zone);
   Array& enum_map_storage =
       Array::Handle(zone, HashTables::New<UnorderedHashMap<EnumMapTraits> >(4));
   ASSERT(!enum_map_storage.IsNull());
 
   TIR_Print("Replacing enum `%s`\n", String::Handle(Name()).ToCString());
 
   {
     UnorderedHashMap<EnumMapTraits> enum_map(enum_map_storage.raw());
     // 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;
       }
       if (enum_ident.Equals(Symbols::Values())) {
         old_enum_values = field.StaticValue();
         // Non-enum instance.
         continue;
       }
+      if (enum_ident.Equals(Symbols::_DeletedEnumSentinel())) {
+        old_deleted_enum_sentinel = field.StaticValue();
+        // Non-enum instance.
+        continue;
+      }
       old_enum_value = field.StaticValue();
       ASSERT(!old_enum_value.IsNull());
       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());
       ASSERT(!update);
     }
     // The storage given to the map may have been reallocated, remember the new
     // address.
     enum_map_storage = enum_map.Release().raw();
   }
 
   bool enums_deleted = false;
   {
     UnorderedHashMap<EnumMapTraits> enum_map(enum_map_storage.raw());
     // 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;
       }
       if (enum_ident.Equals(Symbols::Values())) {
         enum_values = field.StaticValue();
         // Non-enum instance.
         continue;
       }
+      if (enum_ident.Equals(Symbols::_DeletedEnumSentinel())) {
+        deleted_enum_sentinel = field.StaticValue();
+        // Non-enum instance.
+        continue;
+      }
       enum_value = field.StaticValue();
       ASSERT(!enum_value.IsNull());
       old_enum_value ^= enum_map.GetOrNull(enum_ident);
       if (old_enum_value.IsNull()) {
         VTIR_Print("New element %s was not found in mapping\n",
                    enum_ident.ToCString());
       } else {
         VTIR_Print("Adding element `%s` to become mapping\n",
                    enum_ident.ToCString());
         bool removed = enum_map.Remove(enum_ident);
         ASSERT(removed);
         reload_context->AddEnumBecomeMapping(old_enum_value, enum_value);
       }
     }
     enums_deleted = enum_map.NumOccupied() > 0;
     // The storage given to the map may have been reallocated, remember the new
     // address.
     enum_map_storage = enum_map.Release().raw();
   }
 
   // Map the old E.values array to the new E.values array.
   ASSERT(!old_enum_values.IsNull());
   ASSERT(!enum_values.IsNull());
   reload_context->AddEnumBecomeMapping(old_enum_values, enum_values);
 
-  if (enums_deleted && FLAG_trace_reload_verbose) {
+  // 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->AddEnumBecomeMapping(old_deleted_enum_sentinel,
+                                       deleted_enum_sentinel);
+
+  if (enums_deleted) {
+    // Map all deleted enums to the deleted enum senintel value.
     // TODO(johnmccutchan): Add this to the reload 'notices' list.
     VTIR_Print(
-        "The following enum values were deleted and are forever lost in "
-        "the heap:\n");
+        "The following enum values were deleted from %s and will become the "
+        "deleted enum sentinel:\n",
+        old_enum.ToCString());
     UnorderedHashMap<EnumMapTraits> enum_map(enum_map_storage.raw());
     UnorderedHashMap<EnumMapTraits>::Iterator it(&enum_map);
     while (it.MoveNext()) {
       const intptr_t entry = it.Current();
       enum_ident = String::RawCast(enum_map.GetKey(entry));
       ASSERT(!enum_ident.IsNull());
+      old_enum_value ^= enum_map.GetOrNull(enum_ident);
+      VTIR_Print("Element `%s` was deleted\n", enum_ident.ToCString());
+      reload_context->AddEnumBecomeMapping(old_enum_value,
+                                           deleted_enum_sentinel);
     }
     enum_map.Release();
   }
 }
 
 
 void Class::PatchFieldsAndFunctions() const {
   // Move all old functions and fields to a patch class so that they
   // still refer to their original script.
   const PatchClass& patch =
@@ skipping 408 matching lines @@
       const Array& data_array =
           Array::Handle(zone, CachedEmptyICDataArray(num_args));
       set_ic_data_array(data_array);
     }
   }
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart.