Release node factory storage after each demangling operation (swiftlang#35961)

* Release node factory storage after each demangling operation

This adds missing clear() operations to a number of places in
RemoteMirror in order to reclaim memory after (de)mangling results
are no longer needed.

Before this, the RemoteMirror library had an unfortunate tendency to use
excessive amounts of memory as the demangler kept appending data to its
internal slab allocator.

Resolves rdar://72958641

* Include payload cases even if we cannot retrieve the typeinfo

Otherwise, we end up with inconsistent counts of payload and non-payload
cases, which screws up some of the enum management.

* Add a very basic check of enum with CF payload.

Author: tbkka

include/swift/Reflection/TypeRefBuilder.h

@@ -287,6 +287,8 @@ class TypeRefBuilder {
 
   Demangle::NodeFactory &getNodeFactory() { return Dem; }
 
+  void clearNodeFactory() { Dem.clear(); }
+
   BuiltType decodeMangledType(Node *node);
 
   ///

stdlib/public/Reflection/TypeLowering.cpp

@@ -393,7 +393,7 @@ class NoPayloadEnumTypeInfo: public EnumTypeInfo {
                    /*BitwiseTakable*/ true,
                    EnumKind::NoPayloadEnum, Cases) {
     assert(Cases.size() >= 2);
-//    assert(getNumPayloadCases() == 0);
+    assert(getNumPayloadCases() == 0);
   }
 
   bool readExtraInhabitantIndex(remote::MemoryReader &reader,
@@ -437,7 +437,7 @@ class SinglePayloadEnumTypeInfo: public EnumTypeInfo {
     : EnumTypeInfo(Size, Alignment, Stride, NumExtraInhabitants,
                    BitwiseTakable, EnumKind::SinglePayloadEnum, Cases) {
     assert(Cases[0].TR != 0);
-//    assert(getNumPayloadCases() == 1);
+    assert(getNumPayloadCases() == 1);
   }
 
   bool readExtraInhabitantIndex(remote::MemoryReader &reader,
@@ -555,6 +555,7 @@ class SimpleMultiPayloadEnumTypeInfo: public EnumTypeInfo {
     assert(Cases[1].TR != 0);
     assert(getNumPayloadCases() > 1);
     assert(getSize() > getPayloadSize());
+    assert(getCases().size() > 1);
   }
 
   bool readExtraInhabitantIndex(remote::MemoryReader &reader,
@@ -1766,14 +1767,14 @@ class EnumTypeInfoBuilder {
     if (TI == nullptr) {
       DEBUG_LOG(fprintf(stderr, "No TypeInfo for case type: "); TR->dump());
       Invalid = true;
-      return;
+      static TypeInfo emptyTI;
+      Cases.push_back({Name, /*offset=*/0, /*value=*/-1, TR, emptyTI});
+    } else {
+      Size = std::max(Size, TI->getSize());
+      Alignment = std::max(Alignment, TI->getAlignment());
+      BitwiseTakable &= TI->isBitwiseTakable();
+      Cases.push_back({Name, /*offset=*/0, /*value=*/-1, TR, *TI});
     }
-
-    Size = std::max(Size, TI->getSize());
-    Alignment = std::max(Alignment, TI->getAlignment());
-    BitwiseTakable &= TI->isBitwiseTakable();
-
-    Cases.push_back({Name, /*offset=*/0, /*value=*/-1, TR, *TI});
   }
 
 public:
@@ -1800,6 +1801,7 @@ class EnumTypeInfoBuilder {
       } else {
         PayloadCases.push_back(Case);
         auto *CaseTR = getCaseTypeRef(Case);
+        assert(CaseTR != nullptr);
         auto *CaseTI = TC.getTypeInfo(CaseTR, ExternalTypeInfo);
         addCase(Case.Name, CaseTR, CaseTI);
       }

stdlib/public/Reflection/TypeRefBuilder.cpp

@@ -88,7 +88,9 @@ std::string
 TypeRefBuilder::normalizeReflectionName(RemoteRef<char> reflectionName) {
   // Remangle the reflection name to resolve symbolic references.
   if (auto node = demangleTypeRef(reflectionName)) {
-    return mangleNode(node);
+    auto result = mangleNode(node);
+    clearNodeFactory();
+    return result;
   }
 
   // Fall back to the raw string.
@@ -140,6 +142,7 @@ lookupTypeWitness(const std::string &MangledTypeName,
                                                AssocTy->SubstitutedTypeName);
         auto Demangled = demangleTypeRef(SubstitutedTypeName);
         auto *TypeWitness = decodeMangledType(Demangled);
+        clearNodeFactory();
 
         AssociatedTypeCache.insert(std::make_pair(key, TypeWitness));
         return TypeWitness;
@@ -159,6 +162,7 @@ const TypeRef *TypeRefBuilder::lookupSuperclass(const TypeRef *TR) {
 
   auto Demangled = demangleTypeRef(readTypeRef(FD, FD->Superclass));
   auto Unsubstituted = decodeMangledType(Demangled);
+  clearNodeFactory();
   if (!Unsubstituted)
     return nullptr;
 
@@ -192,7 +196,6 @@ TypeRefBuilder::getFieldTypeInfo(const TypeRef *TR) {
       auto CandidateMangledName = readTypeRef(FD, FD->MangledTypeName);
       auto NormalizedName = normalizeReflectionName(CandidateMangledName);
       FieldTypeInfoCache[NormalizedName] = FD;
-      Dem.clear();
     }
   }
 
@@ -230,6 +233,7 @@ bool TypeRefBuilder::getFieldTypeRefs(
 
     auto Demangled = demangleTypeRef(readTypeRef(Field,Field->MangledTypeName));
     auto Unsubstituted = decodeMangledType(Demangled);
+    clearNodeFactory();
     if (!Unsubstituted)
       return false;
 
@@ -308,6 +312,7 @@ TypeRefBuilder::getClosureContextInfo(RemoteRef<CaptureDescriptor> CD) {
       auto MangledName = readTypeRef(CR, CR->MangledTypeName);
       auto DemangleTree = demangleTypeRef(MangledName);
       TR = decodeMangledType(DemangleTree);
+      clearNodeFactory();
     }
     Info.CaptureTypes.push_back(TR);
   }
@@ -320,6 +325,7 @@ TypeRefBuilder::getClosureContextInfo(RemoteRef<CaptureDescriptor> CD) {
       auto MangledName = readTypeRef(MSR, MSR->MangledTypeName);
       auto DemangleTree = demangleTypeRef(MangledName);
       TR = decodeMangledType(DemangleTree);
+      clearNodeFactory();
     }
 
     const MetadataSource *MS = nullptr;
@@ -348,6 +354,7 @@ TypeRefBuilder::dumpTypeRef(RemoteRef<char> MangledName,
   auto TypeName = nodeToString(DemangleTree);
   fprintf(file, "%s\n", TypeName.c_str());
   auto Result = swift::Demangle::decodeMangledType(*this, DemangleTree);
+  clearNodeFactory();
   if (Result.isError()) {
     auto *Error = Result.getError();
     char *ErrorStr = Error->copyErrorString();
@@ -368,6 +375,7 @@ void TypeRefBuilder::dumpFieldSection(FILE *file) {
       auto TypeDemangling =
         demangleTypeRef(readTypeRef(descriptor, descriptor->MangledTypeName));
       auto TypeName = nodeToString(TypeDemangling);
+      clearNodeFactory();
       fprintf(file, "%s\n", TypeName.c_str());
       for (size_t i = 0; i < TypeName.size(); ++i)
         fprintf(file, "-");
@@ -396,6 +404,7 @@ void TypeRefBuilder::dumpAssociatedTypeSection(FILE *file) {
       auto protocolNode = demangleTypeRef(
                          readTypeRef(descriptor, descriptor->ProtocolTypeName));
       auto protocolName = nodeToString(protocolNode);
+      clearNodeFactory();
 
       fprintf(file, "- %s : %s", conformingTypeName.c_str(), protocolName.c_str());
       fprintf(file, "\n");
@@ -420,6 +429,7 @@ void TypeRefBuilder::dumpBuiltinTypeSection(FILE *file) {
       auto typeNode = demangleTypeRef(readTypeRef(descriptor,
                                                   descriptor->TypeName));
       auto typeName = nodeToString(typeNode);
+      clearNodeFactory();
 
       fprintf(file, "\n- %s:\n", typeName.c_str());
       fprintf(file, "Size: %u\n", descriptor->Size);

validation-test/Reflection/reflect_Enum_SingleCaseCFPayload.swift

@@ -0,0 +1,69 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -g -lswiftSwiftReflectionTest %s -o %t/reflect_Enum_SingleCaseCFPayload
+// RUN: %target-codesign %t/reflect_Enum_SingleCaseCFPayload
+
+// RUN: %target-run %target-swift-reflection-test %t/reflect_Enum_SingleCaseCFPayload | %FileCheck %s --check-prefix=CHECK-%target-ptrsize
+
+// REQUIRES: objc_interop
+// REQUIRES: reflection_test_support
+// REQUIRES: executable_test
+// UNSUPPORTED: use_os_stdlib
+
+import SwiftReflectionTest
+import Foundation
+
+enum SingleCaseCFPayloadEnum {
+case only(CFString)
+}
+
+let cfs1 = "1" as CFString
+let cfs2 = "2" as CFString
+
+class ClassWithSingleCaseCFPayloadEnum {
+  var e1: SingleCaseCFPayloadEnum?
+  var e2: SingleCaseCFPayloadEnum = .only(cfs1)
+  var e3: SingleCaseCFPayloadEnum? = .some(.only(cfs2))
+  var e4: SingleCaseCFPayloadEnum??
+}
+
+reflect(object: ClassWithSingleCaseCFPayloadEnum())
+
+// CHECK-64: Reflecting an object.
+// CHECK-64: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}}
+// CHECK-64: Type reference:
+// CHECK-64: (class reflect_Enum_SingleCaseCFPayload.ClassWithSingleCaseCFPayloadEnum)
+// CHECK-64: Type info:
+// CHECK-64: <null type info>
+
+// CHECK-32: Reflecting an object.
+// CHECK-32: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}}
+// CHECK-32: Type reference:
+// CHECK-32: (class reflect_Enum_SingleCaseCFPayload.ClassWithSingleCaseCFPayloadEnum)
+// CHECK-32: Type info:
+// CHECK-32: <null type info>
+
+reflect(enum: SingleCaseCFPayloadEnum.only(cfs1))
+
+// CHECK-64: Reflecting an enum.
+// CHECK-64: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}}
+// CHECK-64: Type reference:
+// CHECK-64: (enum reflect_Enum_SingleCaseCFPayload.SingleCaseCFPayloadEnum)
+// CHECK-64: Type info:
+// CHECK-64: <null type info>
+// CHECK-64: Enum value:
+// CHECK-64: <null type info>
+
+// CHECK-32: Reflecting an enum.
+// CHECK-32: Instance pointer in child address space: 0x{{[0-9a-fA-F]+}}
+// CHECK-32: Type reference:
+// CHECK-32: (enum reflect_Enum_SingleCaseCFPayload.SingleCaseCFPayloadEnum)
+// CHECK-32: Type info:
+// CHECK-32: <null type info>
+// CHECK-32: Enum value:
+// CHECK-32: <null type info>
+
+doneReflecting()
+
+// CHECK-64: Done.
+
+// CHECK-32: Done.