Map deleted enum values to a sentinel value.

runtime/vm/class_finalizer.cc

 // Copyright (c) 2013, 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/class_finalizer.h"
 
 #include "vm/code_generator.h"
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
@@ skipping 2460 matching lines @@
   ASSERT(!index_field.IsNull());
   const Field& name_field = Field::Handle(
       zone, enum_cls.LookupInstanceFieldAllowPrivate(Symbols::_name()));
   ASSERT(!name_field.IsNull());
   const Field& values_field =
       Field::Handle(zone, enum_cls.LookupStaticField(Symbols::Values()));
   ASSERT(!values_field.IsNull());
   ASSERT(Instance::Handle(zone, values_field.StaticValue()).IsArray());
   Array& values_list =
       Array::Handle(zone, Array::RawCast(values_field.StaticValue()));
+  const String& enum_name = String::Handle(enum_cls.ScrubbedName());
+  const String& name_prefix =
+      String::Handle(String::Concat(enum_name, Symbols::Dot()));
+
+  const String& deleted_enum_senintel_name = String::Handle(
+      zone,
+      Symbols::FromConcat(thread, Symbols::_DeletedEnumPrefix(), enum_name));
+  Instance& deleted_enum_sentinel_value =
+      Instance::Handle(zone, Instance::New(enum_cls, Heap::kOld));
+  deleted_enum_sentinel_value.SetField(index_field,
+                                       Smi::Handle(zone, Smi::New(-1)));
+  deleted_enum_sentinel_value.SetField(name_field, deleted_enum_senintel_name);
+  const char* error_msg = NULL;
+  deleted_enum_sentinel_value =
+      deleted_enum_sentinel_value.CheckAndCanonicalize(thread, &error_msg);
+  ASSERT(!deleted_enum_sentinel_value.IsNull());
+  ASSERT(deleted_enum_sentinel_value.IsCanonical());
+  const Field& deleted_enum_field = Field::Handle(
+      zone, enum_cls.LookupStaticField(Symbols::_DeletedEnumSentinel()));
+  ASSERT(!deleted_enum_field.IsNull());
+  deleted_enum_field.SetStaticValue(deleted_enum_sentinel_value, true);
+  deleted_enum_field.RecordStore(deleted_enum_sentinel_value);
 
   const Array& fields = Array::Handle(zone, enum_cls.fields());
   Field& field = Field::Handle(zone);
   Instance& ordinal_value = Instance::Handle(zone);
   Instance& enum_value = Instance::Handle(zone);
 
-  const String& enum_name = String::Handle(enum_cls.ScrubbedName());
-  const String& name_prefix =
-      String::Handle(String::Concat(enum_name, Symbols::Dot()));
-
   String& enum_ident = String::Handle();

[siva, 2016/11/14 22:18:23]

A samll nit, the same handles created here field, enum_value, enum_ident etc.
could be used for the code above instead of creating a new set of handles
deleted_enum_field, deleted_enum_sentinel_value, deleted_enum_sentinel_name.

[Cutch, 2016/11/15 22:13:55]

Done.

   for (intptr_t i = 0; i < fields.Length(); i++) {
     field = Field::RawCast(fields.At(i));
     if (!field.is_static()) continue;
     ordinal_value = field.StaticValue();
     // The static fields that need to be initialized with enum instances
     // contain the smi value of the ordinal number, which was stored in
     // the field by the parser. Other fields contain non-smi values.
     if (!ordinal_value.IsSmi()) continue;
     enum_ident = field.name();
     // Construct the string returned by toString.
     ASSERT(!enum_ident.IsNull());
     // For the user-visible name of the enumeration value, we need to
     // unmangle private names.
     if (enum_ident.CharAt(0) == '_') {
       enum_ident = String::ScrubName(enum_ident);
     }
     enum_ident = Symbols::FromConcat(thread, name_prefix, enum_ident);
     enum_value = Instance::New(enum_cls, Heap::kOld);
     enum_value.SetField(index_field, ordinal_value);
     enum_value.SetField(name_field, enum_ident);
-    const char* error_msg = "";
     enum_value = enum_value.CheckAndCanonicalize(thread, &error_msg);
     ASSERT(!enum_value.IsNull());
     ASSERT(enum_value.IsCanonical());
     field.SetStaticValue(enum_value, true);
     field.RecordStore(enum_value);
     intptr_t ord = Smi::Cast(ordinal_value).Value();
     ASSERT(ord < values_list.Length());
     values_list.SetAt(ord, enum_value);
   }
   values_list.MakeImmutable();
-  const char* error_msg = NULL;
   values_list ^= values_list.CheckAndCanonicalize(thread, &error_msg);
   ASSERT(!values_list.IsNull());
 }
 
 
 bool ClassFinalizer::IsSuperCycleFree(const Class& cls) {
   Class& test1 = Class::Handle(cls.raw());
   Class& test2 = Class::Handle(cls.SuperClass());
   // A finalized class has been checked for cycles.
   // Using the hare and tortoise algorithm for locating cycles.
@@ skipping 733 matching lines @@
   ASSERT(fields_array.Length() == ByteBuffer::NumberOfFields());
   field ^= fields_array.At(0);
   ASSERT(field.Offset() == ByteBuffer::data_offset());
   name ^= field.name();
   expected_name ^= String::New("_data");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 #endif
 }
 
 }  // namespace dart