Merge pull request #9189 from slavapestov/anyobject-removal-vol-3

AnyObject removal volume 3

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

include/swift/Reflection/TypeRefBuilder.h

@@ -134,6 +134,8 @@ class TypeRefBuilder {
   TypeRefBuilder &operator=(const TypeRefBuilder &other) = delete;
 
 private:
+  Demangle::Demangler Dem;
+
   /// Makes sure dynamically allocated TypeRefs stick around for the life of
   /// this TypeRefBuilder and are automatically released.
   std::vector<std::unique_ptr<const TypeRef>> TypeRefPool;
@@ -314,8 +316,8 @@ class TypeRefBuilder {
   const FieldDescriptor *getFieldTypeInfo(const TypeRef *TR);
 
   /// Get the parsed and substituted field types for a nominal type.
-  std::vector<FieldTypeInfo>
-  getFieldTypeRefs(const TypeRef *TR, const FieldDescriptor *FD);
+  bool getFieldTypeRefs(const TypeRef *TR, const FieldDescriptor *FD,
+                        std::vector<FieldTypeInfo> &Fields);
 
   /// Get the primitive type lowering for a builtin type.
   const BuiltinTypeDescriptor *getBuiltinTypeInfo(const TypeRef *TR);

lib/AST/DiagnosticEngine.cpp

@@ -323,16 +323,18 @@ static bool isInterestingTypealias(Type type) {
   if (type->is<BuiltinType>())
     return false;
 
-  auto underlyingTy = aliasTy->getDecl()->getUnderlyingTypeLoc().getType();
+  auto aliasDecl = aliasTy->getDecl();
 
-  // A typealias that directly points at Builtin.AnyObject is not
-  // 'interesting', since it is in fact the AnyObject typealias in
-  // the standard library.
-  if (underlyingTy->isAnyObject() &&
-      isa<ProtocolCompositionType>(underlyingTy.getPointer()))
+  // The 'Swift.AnyObject' typealias is not 'interesting'.
+  if (aliasDecl->getName() ==
+      aliasDecl->getASTContext().getIdentifier("AnyObject") &&
+      aliasDecl->getParentModule()->isStdlibModule()) {
     return false;
+  }
+
+  auto underlyingTy = aliasDecl->getUnderlyingTypeLoc().getType();
 
-  if (aliasTy->getDecl()->isCompatibilityAlias())
+  if (aliasDecl->isCompatibilityAlias())
     return isInterestingTypealias(underlyingTy);
 
   return true;

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/TypeLowering.cpp

@@ -878,7 +878,13 @@ class EnumTypeInfoBuilder {
     unsigned NoPayloadCases = 0;
     std::vector<FieldTypeInfo> PayloadCases;
 
-    for (auto Case : TC.getBuilder().getFieldTypeRefs(TR, FD)) {
+    std::vector<FieldTypeInfo> Fields;
+    if (!TC.getBuilder().getFieldTypeRefs(TR, FD, Fields)) {
+      Invalid = true;
+      return nullptr;
+    }
+
+    for (auto Case : Fields) {
       if (Case.TR == nullptr) {
         NoPayloadCases++;
         continue;
@@ -1024,7 +1030,12 @@ class LowerType
       // Lower the struct's fields using substitutions from the
       // TypeRef to make field types concrete.
       RecordTypeInfoBuilder builder(TC, RecordKind::Struct);
-      for (auto Field : TC.getBuilder().getFieldTypeRefs(TR, FD))
+
+      std::vector<FieldTypeInfo> Fields;
+      if (!TC.getBuilder().getFieldTypeRefs(TR, FD, Fields))
+        return nullptr;
+
+      for (auto Field : Fields)
         builder.addField(Field.Name, Field.TR);
       return builder.build();
     }
@@ -1266,11 +1277,15 @@ const TypeInfo *TypeConverter::getClassInstanceTypeInfo(const TypeRef *TR,
     // TypeRef to make field types concrete.
     RecordTypeInfoBuilder builder(*this, RecordKind::ClassInstance);
 
+    std::vector<FieldTypeInfo> Fields;
+    if (!getBuilder().getFieldTypeRefs(TR, FD, Fields))
+      return nullptr;
+
     // Start layout from the given instance start offset. This should
     // be the superclass instance size.
     builder.addField(start, 1, /*numExtraInhabitants=*/0);
 
-    for (auto Field : getBuilder().getFieldTypeRefs(TR, FD))
+    for (auto Field : Fields)
       builder.addField(Field.Name, Field.TR);
     return builder.build();
   }

stdlib/public/Reflection/TypeRefBuilder.cpp

@@ -49,7 +49,6 @@ lookupTypeWitness(const std::string &MangledTypeName,
         continue;
 
       std::string ProtocolMangledName(AssocTyDescriptor.ProtocolTypeName);
-      Demangle::Demangler Dem;
       auto DemangledProto = Dem.demangleType(ProtocolMangledName);
       auto TR = swift::remote::decodeMangledType(*this, DemangledProto);
 
@@ -82,19 +81,16 @@ 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)
+  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 *
@@ -124,15 +120,15 @@ TypeRefBuilder::getFieldTypeInfo(const TypeRef *TR) {
   return nullptr;
 }
 
-std::vector<FieldTypeInfo>
-TypeRefBuilder::getFieldTypeRefs(const TypeRef *TR, const FieldDescriptor *FD) {
+
+bool TypeRefBuilder::getFieldTypeRefs(const TypeRef *TR,
+                                      const FieldDescriptor *FD,
+                                      std::vector<FieldTypeInfo> &Fields) {
   if (FD == nullptr)
-    return {};
+    return false;
 
   auto Subs = TR->getSubstMap();
 
-  Demangle::Demangler Dem;
-  std::vector<FieldTypeInfo> Fields;
   for (auto &Field : *FD) {
     auto FieldName = Field.getFieldName();
 
@@ -145,7 +141,7 @@ TypeRefBuilder::getFieldTypeRefs(const TypeRef *TR, const FieldDescriptor *FD) {
     auto Demangled = Dem.demangleType(Field.getMangledTypeName());
     auto Unsubstituted = swift::remote::decodeMangledType(*this, Demangled);
     if (!Unsubstituted)
-      return {};
+      return false;
 
     auto Substituted = Unsubstituted->subst(*this, Subs);
 
@@ -156,7 +152,7 @@ TypeRefBuilder::getFieldTypeRefs(const TypeRef *TR, const FieldDescriptor *FD) {
 
     Fields.push_back(FieldTypeInfo::forField(FieldName, Substituted));
   }
-  return Fields;
+  return true;
 }
 
 const BuiltinTypeDescriptor *
@@ -208,7 +204,6 @@ ClosureContextInfo
 TypeRefBuilder::getClosureContextInfo(const CaptureDescriptor &CD) {
   ClosureContextInfo Info;
 
-  Demangle::Demangler Dem;
   for (auto i = CD.capture_begin(), e = CD.capture_end(); i != e; ++i) {
     const TypeRef *TR = nullptr;
     if (i->hasMangledTypeName()) {
@@ -251,7 +246,6 @@ TypeRefBuilder::dumpTypeRef(const std::string &MangledName,
   auto TypeName = Demangle::demangleTypeAsString(MangledName);
   OS << TypeName << '\n';
 
-  Demangle::Demangler Dem;
   auto DemangleTree = Dem.demangleType(MangledName);
   auto TR = swift::remote::decodeMangledType(*this, DemangleTree);
   if (!TR) {