Implement enum types in VM

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 2328 matching lines @@
   // Run additional checks after all types are finalized.
   if (cls.is_const()) {
     CheckForLegalConstClass(cls);
   }
   if (FLAG_use_cha) {
     GrowableArray<intptr_t> cids;
     CollectFinalizedSuperClasses(cls, &cids);
     CollectImmediateSuperInterfaces(cls, &cids);
     RemoveCHAOptimizedCode(cids);
   }
+  if (cls.is_enum_class()) {
+    AllocateEnumValues(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).
+void ClassFinalizer::AllocateEnumValues(const Class &enum_cls) {
+  const Field& index_field =
+      Field::Handle(enum_cls.LookupInstanceField(Symbols::Index()));
+  ASSERT(!index_field.IsNull());
+  const Field& values_field =
+      Field::Handle(enum_cls.LookupStaticField(Symbols::Values()));
+  ASSERT(!values_field.IsNull());
+  ASSERT(Instance::Handle(values_field.value()).IsArray());
+  Array& values_list = Array::Handle(Array::RawCast(values_field.value()));
+
+  const Array& fields = Array::Handle(enum_cls.fields());
+  Field& field = Field::Handle();
+  Instance& ordinal_value = Instance::Handle();
+  Instance& enum_value = Instance::Handle();
+
+  for (intptr_t i = 0; i < fields.Length(); i++) {
+    field = Field::RawCast(fields.At(i));
+    if (!field.is_static()) continue;
+    ordinal_value = field.value();
+    // 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_value = Instance::New(enum_cls, Heap::kOld);
+    enum_value.SetField(index_field, ordinal_value);
+    field.set_value(enum_value);
+    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();
 }
 
 
 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.
   while (!test1.is_type_finalized() &&
          !test2.IsNull() && !test2.is_type_finalized()) {
@@ skipping 360 matching lines @@
     ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend 'dynamic'",
                 String::Handle(isolate, cls.Name()).ToCString());
   }
   interface_class = super_type.type_class();
   if (interface_class.IsSignatureClass()) {
     ReportError(cls, cls.token_pos(),
                 "class '%s' may not extend function type alias '%s'",
                 String::Handle(isolate, cls.Name()).ToCString(),
                 String::Handle(isolate,
-                                  super_type.UserVisibleName()).ToCString());
+                               super_type.UserVisibleName()).ToCString());
+  }
+  if (interface_class.is_enum_class()) {
+    ReportError(cls, cls.token_pos(),
+                "class '%s' may not extend enum '%s'",
+                String::Handle(isolate, cls.Name()).ToCString(),
+                String::Handle(isolate, interface_class.Name()).ToCString());
   }
 
   // If cls belongs to core lib or to core lib's implementation, restrictions
   // about allowed interfaces are lifted.
   if (!cls_belongs_to_core_lib) {
     // Prevent extending core implementation classes.
     bool is_error = false;
     switch (interface_class.id()) {
       case kNumberCid:
       case kIntegerCid:  // Class Integer, not int.
@@ skipping 56 matching lines @@
                   "'dynamic' may not be used as interface");
     }
     interface_class = interface.type_class();
     if (interface_class.IsSignatureClass()) {
       const String& interface_name = String::Handle(isolate,
                                                     interface_class.Name());
       ReportError(cls, cls.token_pos(),
                   "function type alias '%s' may not be used as interface",
                   interface_name.ToCString());
     }
+    if (interface_class.is_enum_class()) {
+      const String& interface_name = String::Handle(isolate,
+                                                    interface_class.Name());
+      ReportError(cls, cls.token_pos(),
+                  "enum '%s' may not be used as interface",
+                  interface_name.ToCString());
+    }
     // Verify that unless cls belongs to core lib, it cannot extend, implement,
     // or mixin any of Null, bool, num, int, double, String, dynamic.
     if (!cls_belongs_to_core_lib) {
       if (interface.IsBoolType() ||
           interface.IsNullType() ||
           interface.IsNumberType() ||
           interface.IsIntType() ||
           interface.IsDoubleType() ||
           interface.IsStringType() ||
           interface.IsDynamicType()) {
@@ skipping 267 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