Merge pull request #29905 from slavapestov/reflection-zero-edition-5.2

IRGen: Fix reflection metadata for zero-sized enum cases [5.2]

Author: slavapestov

lib/IRGen/GenReflection.cpp

@@ -678,7 +678,7 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
   const NominalTypeDecl *NTD;
 
   void addFieldDecl(const ValueDecl *value, Type type,
-                    GenericSignature genericSig, bool indirect=false) {
+                    bool indirect=false) {
     reflection::FieldRecordFlags flags;
     flags.setIsIndirectCase(indirect);
     if (auto var = dyn_cast<VarDecl>(value))
@@ -689,6 +689,8 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
     if (!type) {
       B.addInt32(0);
     } else {
+      auto genericSig = NTD->getGenericSignature();
+
       // The standard library's Mirror demangles metadata from field
       // descriptors, so use MangledTypeRefRole::Metadata to ensure
       // runtime metadata is available.
@@ -722,8 +724,7 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
     auto properties = NTD->getStoredProperties();
     B.addInt32(properties.size());
     for (auto property : properties)
-      addFieldDecl(property, property->getInterfaceType(),
-                   NTD->getGenericSignature());
+      addFieldDecl(property, property->getInterfaceType());
   }
 
   void layoutEnum() {
@@ -748,12 +749,11 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
       bool indirect = (enumCase.decl->isIndirect() ||
                        enumDecl->isIndirect());
       addFieldDecl(enumCase.decl, enumCase.decl->getArgumentInterfaceType(),
-                   enumDecl->getGenericSignature(),
                    indirect);
     }
 
     for (auto enumCase : strategy.getElementsWithNoPayload()) {
-      addFieldDecl(enumCase.decl, CanType(), nullptr);
+      addFieldDecl(enumCase.decl, enumCase.decl->getArgumentInterfaceType());
     }
   }
 

stdlib/public/Reflection/TypeLowering.cpp

@@ -1007,10 +1007,22 @@ class EnumTypeInfoBuilder {
     // NoPayloadEnumImplStrategy
     if (PayloadCases.empty()) {
       Kind = RecordKind::NoPayloadEnum;
-      Size += getEnumTagCounts(/*size=*/0,
-                               NoPayloadCases,
-                               /*payloadCases=*/0).numTagBytes;
-
+      switch (NoPayloadCases) {
+      case 0:
+      case 1: // Zero or one tag has size = 0, extra_inhab = 0
+        NumExtraInhabitants = 0;
+        break;
+      default: { // 2 or more tags
+        auto tagCounts = getEnumTagCounts(/*size=*/0,
+                                          NoPayloadCases,
+                                          /*payloadCases=*/0);
+        Size += tagCounts.numTagBytes;
+        NumExtraInhabitants =
+          (1 << (tagCounts.numTagBytes * 8)) - tagCounts.numTags;
+        NumExtraInhabitants = std::min(NumExtraInhabitants,
+                     unsigned(ValueWitnessFlags::MaxNumExtraInhabitants));
+      }
+      }
     // SinglePayloadEnumImplStrategy
     } else if (PayloadCases.size() == 1) {
       auto *CaseTR = getCaseTypeRef(PayloadCases[0]);

test/Reflection/typeref_lowering.swift

@@ -1039,9 +1039,13 @@
 // CHECK-64-NEXT:   (field name=empty offset=0
 // CHECK-64-NEXT:     (no_payload_enum size=0 alignment=1 stride=1 num_extra_inhabitants=0 bitwise_takable=1))
 // CHECK-64-NEXT:   (field name=noPayload offset=0
-// CHECK-64-NEXT:     (no_payload_enum size=1 alignment=1 stride=1 num_extra_inhabitants=0 bitwise_takable=1))
+// CHECK-64-NEXT:     (no_payload_enum size=1 alignment=1 stride=1 num_extra_inhabitants=252 bitwise_takable=1))
 // CHECK-64-NEXT:   (field name=sillyNoPayload offset=1
-// CHECK-64-NEXT:     (no_payload_enum size=1 alignment=1 stride=1 num_extra_inhabitants=0 bitwise_takable=1))
+// CHECK-64-NEXT:    (multi_payload_enum size=1 alignment=1 stride=1 num_extra_inhabitants=252 bitwise_takable=1
+// CHECK-64-NEXT:      (field name=A offset=0
+// CHECK-64-NEXT:        (no_payload_enum size=0 alignment=1 stride=1 num_extra_inhabitants=0 bitwise_takable=1))
+// CHECK-64-NEXT:      (field name=B offset=0
+// CHECK-64-NEXT:        (no_payload_enum size=0 alignment=1 stride=1 num_extra_inhabitants=0 bitwise_takable=1))))
 // CHECK-64-NEXT:   (field name=singleton offset=8
 // CHECK-64-NEXT:     (reference kind=strong refcounting=native))
 // CHECK-64-NEXT:   (field name=singlePayload offset=16

test/stdlib/Mirror.swift

@@ -917,6 +917,28 @@ mirrors.test("Enum/SingletonNonGeneric/DefaultMirror") {
   }
 }
 
+enum ZeroSizedEnumWithDefaultMirror {
+  case π
+}
+
+enum SingletonZeroSizedEnumWithDefaultMirror {
+  case wrap(ZeroSizedEnumWithDefaultMirror)
+}
+
+mirrors.test("Enum/SingletonZeroSizedEnumWithDefaultMirror/DefaultMirror") {
+  do {
+    let value = SingletonZeroSizedEnumWithDefaultMirror.wrap(.π)
+    var output = ""
+    dump(value, to: &output)
+
+    let expected =
+      "▿ Mirror.SingletonZeroSizedEnumWithDefaultMirror.wrap\n" +
+      "  - wrap: Mirror.ZeroSizedEnumWithDefaultMirror.π\n"
+
+    expectEqual(expected, output)
+  }
+}
+
 enum SingletonGenericEnumWithDefaultMirror<T> {
   case OnlyOne(T)
 }
@@ -1994,7 +2016,8 @@ if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *) {
     testSTSDump(STSContainer.Cases<Int>.a(.init()),
                 STSContainer℠.Cases<Int>.a(.init()),
                 """
-      - Mirror.STSContainer<Mirror.STSOuter>.Cases<Swift.Int>.a\n
+      ▿ Mirror.STSContainer<Mirror.STSOuter>.Cases<Swift.Int>.a
+        - a: Mirror.STSOuter\n
       """)
 
     testSTSDump(STSContainer.Cases<Int>.b(.init()),