Various fixes for enum class

Summary:
This diff fixes the following issues that arise from the fact that enum classes are tagged with `AttrEnum` by making `AttrEnum` and `AttrEnumClass` mutually exclusive:

 - Jumpstart serialization assumed that any `AttrEnum` class had a base type that was either `int` or `string` (this was actually doubly wrong as even for enums this type could also have been `arraykey`)
 - A variety of places in hhbbc, the jit, and the runtime treat any `AttrEnum` type name as though it's an alias for the enum's base type. This is not true of enum classes.
 - Checks were missing to prevent enum classes from including enums and vice-versa
 - BuiltinEnumClass was the only class marked AttrEnumClass but not AttrEnum, now it is marked neither to match BuiltinEnum (which is not marked AttrEnum). This made the fix to Class::setParent below possible

Additionally the following mostly benign issues were fixed:

 - Dead code in Class::classof (which would have been broken had it been possible to instantiate an enum class) was removed
 - Dead code in Class::setParent that assumed it was possible to extend an enum class (by means other than enum inclusion) was removed (all enums extend BuiltinEnum and all enum classes extend BuiltinEnumClass)
 - In index.cpp a check for enums which include other enums had erroneously negated a check for AttrEnum
 - In prof-data-serialize.cpp we weren't reading/writing included enums. While not strictly a requirement for correctness it is better to do this here.

Reviewed By: jano

Differential Revision: D27574956

fbshipit-source-id: 36910981a3daf7d5c5c01a48df2f62fd22fd8608

Author: paulbiss

hphp/hack/src/hhbc/print.rs

@@ -751,7 +751,7 @@ fn print_class_special_attributes<W: Write>(
     if c.is_sealed() {
         special_attributes.push("sealed");
     }
-    if c.enum_type.is_some() {
+    if c.enum_type.is_some() && !hhas_attribute::has_enum_class(user_attrs) {
         special_attributes.push("enum");
     }
     if c.is_abstract() {

hphp/hack/test/enum_atom/compilation/test.php.exp

@@ -116,7 +116,7 @@
   }
 }
 
-.class {} [enum enum_class "__EnumClass"("""v:0:{}""")] E (16,19) extends HH\BuiltinEnumClass {
+.class {} [enum_class "__EnumClass"("""v:0:{}""")] E (16,19) extends HH\BuiltinEnumClass {
   .enum_ty <"I" extended_hint>;
   .const A = uninit;
   .const B = uninit;
@@ -181,7 +181,7 @@
   }
 }
 
-.class {} [enum enum_class "__EnumClass"("""v:0:{}""")] F (25,27) extends HH\BuiltinEnumClass enum_includes (E) {
+.class {} [enum_class "__EnumClass"("""v:0:{}""")] F (25,27) extends HH\BuiltinEnumClass enum_includes (E) {
   .enum_ty <"I" extended_hint>;
   .const C = uninit;
   .method {}{} [private static no_injection] (25,27) 86cinit($constName) {

hphp/hhbbc/index.cpp

@@ -1564,7 +1564,7 @@ bool build_class_constants(BuildClsInfo& info,
 
       // A constant from an interface or from an included enum collides
       // with an existing constant.
-      if (rparent->cls->attrs & (AttrInterface | AttrEnum)) {
+      if (rparent->cls->attrs & (AttrInterface | AttrEnum | AttrEnumClass)) {
         ITRACE(2,
                "build_cls_info_rec failed for `{}' because "
                "`{}' was defined by both `{}' and `{}'\n",
@@ -2658,11 +2658,13 @@ void resolve_combinations(ClassNamingEnv& env,
 
   for (auto& included_enum_name : cls->includedEnumNames) {
     auto const included_enum = map.at(included_enum_name);
-    if (!(included_enum->cls->attrs & AttrEnum)) {
+    auto const want_attr = cls->attrs & (AttrEnum | AttrEnumClass);
+    if (!(included_enum->cls->attrs & want_attr)) {
       ITRACE(2,
              "Resolve combinations failed for `{}' because `{}' "
-             "is not an enum\n",
-             cls->name, included_enum_name);
+             "is not an enum{}\n",
+             cls->name, included_enum_name,
+             want_attr & AttrEnumClass ? " class" : "");
       return;
     }
     cinfo->includedEnums.push_back(included_enum);
@@ -2780,6 +2782,7 @@ void compute_subclass_list(IndexData& index) {
   trace_time _("compute subclass list");
   auto fixupTraits = false;
   auto fixupEnums = false;
+  auto const AnyEnum = AttrEnum | AttrEnumClass;
   for (auto& cinfo : index.allClassInfos) {
     if (cinfo->cls->attrs & AttrInterface) continue;
     for (auto& cparent : cinfo->baseList) {
@@ -2791,13 +2794,13 @@ void compute_subclass_list(IndexData& index) {
       compute_subclass_list_rec(index, cinfo.get(), cinfo.get());
     }
     // Add the included enum lists if cinfo is an enum
-    if (!(cinfo->cls->attrs & AttrEnum) &&
+    if ((cinfo->cls->attrs & AnyEnum) &&
         cinfo->cls->includedEnumNames.size()) {
       fixupEnums = true;
       compute_included_enums_list_rec(index, cinfo.get(), cinfo.get());
     }
     // Also add instantiable classes to their interface's subclassLists
-    if (cinfo->cls->attrs & (AttrTrait | AttrEnum | AttrAbstract)) continue;
+    if (cinfo->cls->attrs & (AttrTrait | AnyEnum | AttrAbstract)) continue;
     for (auto& ipair : cinfo->implInterfaces) {
       auto impl = const_cast<ClassInfo*>(ipair.second);
       impl->subclassList.push_back(cinfo.get());
@@ -2807,7 +2810,7 @@ void compute_subclass_list(IndexData& index) {
   for (auto& cinfo : index.allClassInfos) {
     auto& sub = cinfo->subclassList;
     if ((fixupTraits && cinfo->cls->attrs & AttrTrait) ||
-        (fixupEnums && cinfo->cls->attrs & AttrEnum)) {
+        (fixupEnums && cinfo->cls->attrs & AnyEnum)) {
       // traits and enums can be reached by multiple paths, so we need to
       // uniquify their subclassLists.
       std::sort(begin(sub), end(sub));
@@ -3027,7 +3030,7 @@ void trace_interfaces(const IndexData& index, const ConflictGraph& cg) {
       ifaces.emplace_back(cinfo->cls);
       continue;
     }
-    if (cinfo->cls->attrs & (AttrTrait | AttrEnum)) continue;
+    if (cinfo->cls->attrs & (AttrTrait | AttrEnum | AttrEnumClass)) continue;
 
     classes.emplace_back(Cls{cinfo.get()});
     auto& vtable = classes.back().vtable;
@@ -3150,7 +3153,7 @@ void compute_iface_vtables(IndexData& index) {
     }
 
     // Only worry about classes with methods that can be called.
-    if (cinfo->cls->attrs & (AttrTrait | AttrEnum)) continue;
+    if (cinfo->cls->attrs & (AttrTrait | AttrEnum | AttrEnumClass)) continue;
 
     for (auto& ipair : cinfo->implInterfaces) {
       ++iface_uses[ipair.second->cls];

hphp/runtime/base/enum-cache.cpp

@@ -43,13 +43,13 @@ const EnumValues* EnumCache::getValues(const Class* klass,
 }
 
 const EnumValues* EnumCache::getValuesBuiltin(const Class* klass) {
-  assertx(isEnum(klass));
+  assertx(isAnyEnum(klass));
   if (auto const values = klass->getEnumValues()) return values;
   return s_cache.getEnumValues(klass, false);
 }
 
 const EnumValues* EnumCache::getValuesStatic(const Class* klass) {
-  assertx(isEnum(klass));
+  assertx(isAnyEnum(klass));
   auto const result = [&]() -> const EnumValues* {
     if (auto const values = klass->getEnumValues()) return values;
     return s_cache.getEnumValues(klass, false, true);
@@ -144,7 +144,7 @@ const EnumValues* EnumCache::loadEnumValues(
     }
     // The outer condition below enables caching of enum constants defined
     // in enums included by the current class.
-    if (!(isEnum(klass)
+    if (!(isAnyEnum(klass)
         && klass->hasIncludedEnums()
         && klass->allIncludedEnums().contains(consts[i].cls->name()))) {
       if (consts[i].cls != klass && !recurse) {

hphp/runtime/base/object-data-inl.h

@@ -120,7 +120,8 @@ template <bool Unlocked>
 NEVER_INLINE ObjectData* ObjectData::newInstanceSlow(Class* cls) {
   assertx(cls);
   if (UNLIKELY(cls->attrs() &
-               (AttrAbstract | AttrInterface | AttrTrait | AttrEnum))) {
+               (AttrAbstract | AttrInterface | AttrTrait | AttrEnum |
+                AttrEnumClass))) {
     raiseAbstractClassError(cls);
   }
   if (cls->hasReifiedGenerics()) {
@@ -158,7 +159,8 @@ inline ObjectData* ObjectData::newInstance(Class* cls) {
     return newInstanceSlow<Unlocked>(cls);
   }
   if (UNLIKELY(cls->attrs() &
-               (AttrAbstract | AttrInterface | AttrTrait | AttrEnum))) {
+               (AttrAbstract | AttrInterface | AttrTrait | AttrEnum |
+                AttrEnumClass))) {
     raiseAbstractClassError(cls);
   }
   auto obj = ObjectData::newInstanceImpl<Unlocked>(
@@ -176,7 +178,8 @@ inline ObjectData* ObjectData::newInstanceReified(Class* cls,
                                                   ArrayData* reifiedTypes) {
   assertx(cls);
   if (UNLIKELY(cls->attrs() &
-               (AttrAbstract | AttrInterface | AttrTrait | AttrEnum))) {
+               (AttrAbstract | AttrInterface | AttrTrait | AttrEnum |
+                AttrEnumClass))) {
     raiseAbstractClassError(cls);
   }
   if (cls->hasReifiedGenerics()) {
@@ -207,7 +210,8 @@ inline ObjectData* ObjectData::newInstanceReified(Class* cls,
 
 inline ObjectData* ObjectData::newInstanceNoPropInit(Class* cls) {
   assertx(!(cls->attrs() &
-            (AttrAbstract | AttrInterface | AttrTrait | AttrEnum)));
+            (AttrAbstract | AttrInterface | AttrTrait | AttrEnum |
+             AttrEnumClass)));
   return ObjectData::newInstanceImpl<false>(
     cls,
     [&](void* mem, uint8_t sizeFlag) {

hphp/runtime/base/object-data.cpp

@@ -1554,7 +1554,7 @@ void ObjectData::raiseAbstractClassError(Class* cls) {
   raise_error("Cannot instantiate %s %s",
               (attrs & AttrInterface) ? "interface" :
               (attrs & AttrTrait)     ? "trait" :
-              (attrs & AttrEnum)      ? "enum" : "abstract class",
+              (attrs & (AttrEnum|AttrEnumClass)) ? "enum" : "abstract class",
               cls->preClass()->name()->data());
 }
 

hphp/runtime/base/type-structure.cpp

@@ -602,7 +602,7 @@ bool resolveClass(TSEnv& env, const TSCtx& ctx, Array& ret,
   if (!cls) return false;
 
   TypeStructure::Kind resolvedKind;
-  if (isNormalClass(cls)) {
+  if (isNormalClass(cls) || isEnumClass(cls)) {
     resolvedKind = TypeStructure::Kind::T_class;
   } else if (isInterface(cls)) {
     resolvedKind = TypeStructure::Kind::T_interface;

hphp/runtime/ext/enum/ext_enum.php

@@ -87,7 +87,6 @@ final public static function assertAll(
  * definition below is not actually used at run time; it is simply
  * provided for the typechecker and for developer reference.
  */
-<<__EnumClass>>
 abstract class BuiltinEnumClass<+T> {
   /**
    * Get the values of the public consts defined on this class,

hphp/runtime/ext/reflection/ext_reflection.cpp

@@ -1142,7 +1142,8 @@ static bool HHVM_METHOD(ReflectionClass, isInternal) {
 
 static bool HHVM_METHOD(ReflectionClass, isInstantiable) {
   auto const cls = ReflectionClassHandle::GetClassFor(this_);
-  return !(cls->attrs() & (AttrAbstract | AttrInterface | AttrTrait | AttrEnum))
+  return !(cls->attrs() & (AttrAbstract | AttrInterface | AttrTrait | AttrEnum |
+                           AttrEnumClass))
     && (cls->getCtor()->attrs() & AttrPublic);
 }
 
@@ -1168,12 +1169,12 @@ static bool HHVM_METHOD(ReflectionClass, isTrait) {
 
 static bool HHVM_METHOD(ReflectionClass, isEnum) {
   auto const cls = ReflectionClassHandle::GetClassFor(this_);
-  return cls->attrs() & AttrEnum;
+  return cls->attrs() & (AttrEnum|AttrEnumClass);
 }
 
 static String HHVM_METHOD(ReflectionClass, getEnumUnderlyingType) {
   auto const cls = ReflectionClassHandle::GetClassFor(this_);
-  if (!(cls->attrs() & AttrEnum)) {
+  if (!(cls->attrs() & (AttrEnum|AttrEnumClass))) {
     Reflection::ThrowReflectionExceptionObject(
       "Trying to read the Enum-type of a non-Enum");
   }

hphp/runtime/ext/std/ext_std_classobj.cpp

@@ -96,7 +96,7 @@ bool HHVM_FUNCTION(trait_exists, const String& trait_name,
 bool HHVM_FUNCTION(enum_exists, const String& enum_name,
                    bool autoload /* = true */) {
   Class* cls = Class::get(enum_name.get(), autoload);
-  return cls && isEnum(cls);
+  return cls && isAnyEnum(cls);
 }
 
 Variant HHVM_FUNCTION(get_class_methods, const Variant& class_or_object) {