Reflection: Record superclass as its own field instead of an associated type of AnyObject

The "superclass as associated type" modeling was put in to
maintain backward compatibility.

We just bumped the version number because of new mangling so
we may as well fix this sillyness too.

Author: slavapestov

include/swift/Reflection/Records.h

@@ -19,7 +19,7 @@
 
 #include "swift/Basic/RelativePointer.h"
 
-const uint16_t SWIFT_REFLECTION_METADATA_VERSION = 2; // use new mangling
+const uint16_t SWIFT_REFLECTION_METADATA_VERSION = 3; // superclass field
 
 namespace swift {
 namespace reflection {
@@ -145,6 +145,7 @@ class FieldDescriptor {
   }
 
   const RelativeDirectPointer<const char> MangledTypeName;
+  const RelativeDirectPointer<const char> Superclass;
 
 public:
   FieldDescriptor() = delete;
@@ -190,6 +191,14 @@ class FieldDescriptor {
   std::string getMangledTypeName() const {
     return MangledTypeName.get();
   }
+
+  bool hasSuperclass() const {
+    return Superclass;
+  }
+
+  std::string getSuperclass() const {
+    return Superclass.get();
+  }
 };
 
 class FieldDescriptorIterator

lib/IRGen/GenReflection.cpp

@@ -321,43 +321,6 @@ class AssociatedTypeMetadataBuilder : public ReflectionMetadataBuilder {
   }
 };
 
-class SuperclassMetadataBuilder : public ReflectionMetadataBuilder {
-  static const uint32_t AssociatedTypeRecordSize = 8;
-
-  const ClassDecl *Class;
-  CanType Superclass;
-
-  void layout() override {
-    PrettyStackTraceDecl DebugStack("emitting superclass metadata",
-                                    Class);
-
-    auto *M = IGM.getSILModule().getSwiftModule();
-
-    addTypeRef(M, Class->getDeclaredType()->getCanonicalType());
-    addTypeRef(M, IGM.Context.getAnyObjectType());
-
-    B.addInt32(1);
-    B.addInt32(AssociatedTypeRecordSize);
-
-    auto NameGlobal = IGM.getAddrOfStringForTypeRef("super");
-    B.addRelativeAddress(NameGlobal);
-    addTypeRef(M, Superclass);
-  }
-
-public:
-  SuperclassMetadataBuilder(IRGenModule &IGM,
-                            const ClassDecl *Class,
-                            CanType Superclass)
-    : ReflectionMetadataBuilder(IGM), Class(Class),
-      Superclass(Superclass) {}
-
-  llvm::GlobalVariable *emit() {
-    auto entity = LinkEntity::forReflectionSuperclassDescriptor(Class);
-    auto section = IGM.getAssociatedTypeMetadataSectionName();
-    return ReflectionMetadataBuilder::emit(entity, section);
-  }
-};
-
 class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
   const uint32_t fieldRecordSize = 12;
   const NominalTypeDecl *NTD;
@@ -465,15 +428,23 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
   }
 
   void layout() override {
-    PrettyStackTraceDecl DebugStack("emitting field type metadata", NTD);
-    auto type = NTD->getDeclaredType()->getCanonicalType();
-    addTypeRef(NTD->getModuleContext(), type);
-
     if (NTD->hasClangNode() &&
         !isa<ClassDecl>(NTD) &&
         !isa<ProtocolDecl>(NTD))
       return;
 
+    PrettyStackTraceDecl DebugStack("emitting field type metadata", NTD);
+    auto type = NTD->getDeclaredType()->getCanonicalType();
+    addTypeRef(NTD->getModuleContext(), type);
+
+    auto *CD = dyn_cast<ClassDecl>(NTD);
+    if (CD && CD->getSuperclass()) {
+      addTypeRef(NTD->getModuleContext(),
+                 CD->getSuperclass()->getCanonicalType());
+    } else {
+      B.addInt32(0);
+    }
+
     switch (NTD->getKind()) {
     case DeclKind::Class:
     case DeclKind::Struct:
@@ -992,21 +963,6 @@ void IRGenModule::emitFieldMetadataRecord(const NominalTypeDecl *Decl) {
 
   FieldTypeMetadataBuilder builder(*this, Decl);
   builder.emit();
-
-  // So that -parse-stdlib tests don't need to define an AnyObject
-  // protocol (which will go away one day anyway).
-  if (!Context.getProtocol(KnownProtocolKind::AnyObject))
-    return;
-
-  // If this is a class declaration with a superclass, record the
-  // superclass as a special associated type named 'super' on the
-  // 'AnyObject' protocol.
-  if (auto Superclass = Decl->getDeclaredInterfaceType()
-                            ->getSuperclass()) {
-    SuperclassMetadataBuilder builder(*this, cast<ClassDecl>(Decl),
-                                      Superclass->getCanonicalType());
-    builder.emit();
-  }
 }
 
 void IRGenModule::emitReflectionMetadataVersion() {

stdlib/public/Reflection/TypeRefBuilder.cpp

@@ -82,19 +82,17 @@ lookupSuperclass(const std::string &MangledTypeName) {
 
 const TypeRef * TypeRefBuilder::
 lookupSuperclass(const TypeRef *TR) {
-  const TypeRef *Superclass = nullptr;
-
-  if (auto *Nominal = dyn_cast<NominalTypeRef>(TR)) {
-    Superclass = lookupSuperclass(Nominal->getMangledName());
-  } else {
-    auto BG = cast<BoundGenericTypeRef>(TR);
-    Superclass = lookupSuperclass(BG->getMangledName());
-  }
+  auto *FD = getFieldTypeInfo(TR);
+  if (FD == nullptr)
+    return nullptr;
 
-  if (Superclass == nullptr)
+  Demangle::Demangler Dem;
+  auto Demangled = Dem.demangleType(FD->getSuperclass());
+  auto Unsubstituted = swift::remote::decodeMangledType(*this, Demangled);
+  if (!Unsubstituted)
     return nullptr;
 
-  return Superclass->subst(*this, TR->getSubstMap());
+  return Unsubstituted->subst(*this, TR->getSubstMap());
 }
 
 const FieldDescriptor *