Set correct type for enum values list (fixes #28341).

runtime/vm/parser.cc

 // Copyright (c) 2012, 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/parser.h"
 #include "vm/flags.h"
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 #include "lib/invocation_mirror.h"
@@ skipping 4850 matching lines @@
     }
     for (intptr_t n = 0; n < declared_names.length(); n++) {
       if (enum_ident->Equals(*declared_names[n])) {
         ReportError("Duplicate name '%s' in enum definition '%s'",
                     enum_ident->ToCString(), enum_name.ToCString());
       }
     }
     declared_names.Add(enum_ident);
 
     // Create the static const field for the enumeration value.
+    // Note that we do not set the field type to E, because we temporarily store
+    // a Smi in the field. The class finalizer would detect the bad type and
+    // reset the value to sentinel.
     enum_value = Field::New(*enum_ident,
                             /* is_static = */ true,
                             /* is_final = */ true,
                             /* is_const = */ true,
                             /* is_reflectable = */ true, cls,
                             Object::dynamic_type(), cls.token_pos());
     enum_value.set_has_initializer(false);
     enum_members.AddField(enum_value);
     // Initialize the field with the ordinal value. It will be patched
     // later with the enum constant instance.
     const Smi& ordinal_value = Smi::Handle(Z, Smi::New(i));
     enum_value.SetStaticValue(ordinal_value, true);
     enum_value.RecordStore(ordinal_value);
     i++;
 
     ConsumeToken();  // Enum value name.
     if (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
     }
   }
   ExpectToken(Token::kRBRACE);
 
-  const Type& array_type = Type::Handle(Z, Type::ArrayType());
-  // Add static field 'const List values'.
+  const Class& array_class = Class::Handle(Z, I->object_store()->array_class());
+  TypeArguments& values_type_args =
+      TypeArguments::ZoneHandle(Z, TypeArguments::New(1));
+  const Type& enum_type = Type::Handle(Type::NewNonParameterizedType(cls));
+  values_type_args.SetTypeAt(0, enum_type);
+  Type& values_type = Type::ZoneHandle(
+      Z, Type::New(array_class, values_type_args, cls.token_pos(), Heap::kOld));
+  values_type ^= ClassFinalizer::FinalizeType(cls, values_type,
+                                              ClassFinalizer::kCanonicalize);
+  values_type_args = values_type.arguments();  // Get canonical type arguments.
+  // Add static field 'const List<E> values'.
   Field& values_field = Field::ZoneHandle(Z);
-  values_field =
-      Field::New(Symbols::Values(),
-                 /* is_static = */ true,
-                 /* is_final = */ true,
-                 /* is_const = */ true,
-                 /* is_reflectable = */ true, cls, array_type, cls.token_pos());
+  values_field = Field::New(Symbols::Values(),
+                            /* is_static = */ true,
+                            /* is_final = */ true,
+                            /* is_const = */ true,
+                            /* is_reflectable = */ true, cls, values_type,
+                            cls.token_pos());
   enum_members.AddField(values_field);
 
   // Add static field 'const _deleted_enum_sentinel'.
+  // This field does not need to be of type E.
   Field& deleted_enum_sentinel = Field::ZoneHandle(Z);
   deleted_enum_sentinel = Field::New(Symbols::_DeletedEnumSentinel(),
                                      /* is_static = */ true,
                                      /* is_final = */ true,
                                      /* is_const = */ true,
                                      /* is_reflectable = */ false, cls,
                                      Object::dynamic_type(), cls.token_pos());
   enum_members.AddField(deleted_enum_sentinel);
 
   // Allocate the immutable array containing the enumeration values.
   // The actual enum instance values will be patched in later.
   const Array& values_array = Array::Handle(Z, Array::New(i, Heap::kOld));
+  values_array.SetTypeArguments(values_type_args);
   values_field.SetStaticValue(values_array, true);
   values_field.RecordStore(values_array);
 
   // Clone the _name field from the helper class.
   Field& _name_field = Field::Handle(
       Z, helper_class.LookupInstanceFieldAllowPrivate(Symbols::_name()));
   ASSERT(!_name_field.IsNull());
   _name_field = _name_field.Clone(cls);
   enum_members.AddField(_name_field);
 
@@ skipping 9741 matching lines @@
     const ArgumentListNode& function_args,
     const LocalVariable* temp_for_last_arg,
     bool is_super_invocation) {
   UNREACHABLE();
   return NULL;
 }
 
 }  // namespace dart
 
 #endif  // DART_PRECOMPILED_RUNTIME