Warn when a resilient extension declares a retroactive conformance

It's not particularly _great_ when executable targets declare these, but
it's certainly not okay when a library that's meant to be distributed
declares these. When library evolution is enabled, warn about
retroactive conformances.

To silence the warning, add the @retroactive attribute to the extended type,
similarly to the @unchecked attribute for Sendable. It is an error to use
@retroactive for anything but a retroactive conformance declaration in
an extension.

Fixes rdar://74543558

Author: harlanhaskins

include/swift/AST/Decl.h

@@ -1563,10 +1563,14 @@ struct InheritedEntry : public TypeLoc {
   /// Whether there was an @unchecked attribute.
   bool isUnchecked = false;
 
+  /// Whether there was an @retroactive attribute.
+  bool isRetroactive = false;
+
   InheritedEntry(const TypeLoc &typeLoc);
 
-  InheritedEntry(const TypeLoc &typeLoc, bool isUnchecked)
-    : TypeLoc(typeLoc), isUnchecked(isUnchecked) { }
+  InheritedEntry(const TypeLoc &typeLoc, bool isUnchecked, bool isRetroactive)
+    : TypeLoc(typeLoc), isUnchecked(isUnchecked), isRetroactive(isRetroactive) {
+    }
 };
 
 /// A wrapper for the collection of inherited types for either a `TypeDecl` or

include/swift/AST/DiagnosticsSema.def

@@ -2444,6 +2444,23 @@ NOTE(invalid_extension_rewrite,none,
 ERROR(synthesized_nominal_extension,none,
       "cannot extend synthesized type %0", (Type))
 
+ERROR(retroactive_not_in_extension_inheritance_clause,none,
+      "'retroactive' attribute only applies in inheritance clauses in "
+      "extensions", ())
+
+ERROR(retroactive_attr_does_not_apply,none,
+      "'retroactive' attribute does not apply; %0 is declared in this module",
+      (Identifier))
+
+WARNING(extension_retroactive_conformance,none,
+       "extension declares a conformance of imported type %0 to imported "
+       "%select{protocols|protocol}1 %2; this will not behave correctly if "
+       "the owners of %3 introduce this conformance in the future",
+       (Identifier, bool, StringRef, Identifier))
+
+NOTE(extension_retroactive_conformance_silence,none,
+     "add '@retroactive' to silence this warning", ())
+
 // Protocols
 ERROR(type_does_not_conform,none,
       "type %0 does not conform to protocol %1", (Type, Type))

include/swift/AST/Module.h

@@ -540,6 +540,13 @@ class ModuleDecl
   ///  module if one exists.
   ModuleDecl *getUnderlyingModuleIfOverlay() const;
 
+  /// Returns true if this module is the Clang overlay of \p other.
+  bool isClangOverlayOf(ModuleDecl *other);
+
+  /// Returns true if this module is the same module or either module is a clang
+  /// overlay of the other.
+  bool isSameModuleLookingThroughOverlays(ModuleDecl *other);
+
   /// Returns true if this module is an underscored cross import overlay
   /// declared by \p other or its underlying clang module, either directly or
   /// transitively (via intermediate cross-import overlays - for cross-imports

include/swift/AST/ProtocolConformance.h

@@ -285,6 +285,11 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
   /// is either the default definition or was otherwise deduced.
   bool usesDefaultDefinition(AssociatedTypeDecl *requirement) const;
 
+  /// Determines whether this conformance is retroactive; that is, if the
+  /// conformance's declaration is in a different module from both the
+  /// conforming type and the protocol.
+  bool isRetroactive() const;
+
   /// Print a parseable and human-readable description of the identifying
   /// information of the protocol conformance.
   void printName(raw_ostream &os,

include/swift/AST/TypeRepr.h

@@ -147,9 +147,9 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
   SourceLoc getEndLoc() const;
   SourceRange getSourceRange() const;
 
-  /// Find an @unchecked attribute and return its source location, or return
-  /// an invalid source location if there is no such attribute.
-  SourceLoc findUncheckedAttrLoc() const;
+  /// Find an attribute with the provided kind and return its source location,
+  /// or return an invalid source location if there is no such attribute.
+  SourceLoc findAttrLoc(TypeAttrKind kind) const;
 
   /// Is this type grammatically a type-simple?
   inline bool isSimple() const; // bottom of this file

lib/AST/ASTPrinter.cpp

@@ -343,6 +343,7 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
     DAK_StaticInitializeObjCMetadata,
     DAK_RestatedObjCConformance,
     DAK_NonSendable,
+    TAK_retroactive
   };
 
   return result;
@@ -2579,6 +2580,9 @@ void PrintAST::printInherited(const Decl *decl) {
   interleave(TypesToPrint, [&](InheritedEntry inherited) {
     if (inherited.isUnchecked)
       Printer << "@unchecked ";
+    if (inherited.isRetroactive &&
+        !llvm::is_contained(Options.ExcludeAttrList, TAK_retroactive))
+      Printer << "@retroactive ";
 
     printTypeLoc(inherited);
   }, [&]() {
@@ -7871,7 +7875,8 @@ swift::getInheritedForPrinting(
     }
 
     Results.push_back({TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()),
-                       isUnchecked});
+                       isUnchecked,
+                       /*isRetroactive=*/false});
   }
 }
 

lib/AST/Decl.cpp

@@ -1544,8 +1544,10 @@ NominalTypeDecl::takeConformanceLoaderSlow() {
 
 InheritedEntry::InheritedEntry(const TypeLoc &typeLoc)
     : TypeLoc(typeLoc), isUnchecked(false) {
-  if (auto typeRepr = typeLoc.getTypeRepr())
-    isUnchecked = typeRepr->findUncheckedAttrLoc().isValid();
+  if (auto typeRepr = typeLoc.getTypeRepr()) {
+    isUnchecked = typeRepr->findAttrLoc(TAK_unchecked).isValid();
+    isRetroactive = typeRepr->findAttrLoc(TAK_retroactive).isValid();
+  }
 }
 
 InheritedTypes::InheritedTypes(

lib/AST/Module.cpp

@@ -2909,6 +2909,34 @@ ModuleDecl::getDeclaringModuleAndBystander() {
   return *(declaringModuleAndBystander = {nullptr, Identifier()});
 }
 
+bool ModuleDecl::isClangOverlayOf(ModuleDecl *potentialUnderlying) {
+  return getUnderlyingModuleIfOverlay() == potentialUnderlying;
+}
+
+bool ModuleDecl::isSameModuleLookingThroughOverlays(
+  ModuleDecl *other) {
+  if (this == other) {
+    return true;
+  }
+
+  if (this->isClangOverlayOf(other) || other->isClangOverlayOf(this)) {
+    return true;
+  }
+  
+  // If the type has the @_originallyDefinedIn attribute, check if this is the
+  // "originally defined in" module.
+
+  if (getName().is(other->getAlternateModuleName())) {
+    return true;
+  }
+
+  if (other->getName().is(getAlternateModuleName())) {
+    return true;
+  }
+
+  return false;
+}
+
 bool ModuleDecl::isCrossImportOverlayOf(ModuleDecl *other) {
   ModuleDecl *current = this;
   ModuleDecl *otherClang = other->getUnderlyingModuleIfOverlay();

lib/AST/NameLookup.cpp

@@ -3664,7 +3664,7 @@ void swift::getDirectlyInheritedNominalTypeDecls(
   auto inheritedTypes = InheritedTypes(decl);
   if (TypeRepr *typeRepr = inheritedTypes.getTypeRepr(i)) {
     loc = typeRepr->getLoc();
-    uncheckedLoc = typeRepr->findUncheckedAttrLoc();
+    uncheckedLoc = typeRepr->findAttrLoc(TAK_unchecked);
   }
 
   // Form the result.

lib/AST/ProtocolConformance.cpp

@@ -178,6 +178,26 @@ usesDefaultDefinition(AssociatedTypeDecl *requirement) const {
   CONFORMANCE_SUBCLASS_DISPATCH(usesDefaultDefinition, (requirement))
 }
 
+bool ProtocolConformance::isRetroactive() const {
+  auto extensionModule = getDeclContext()->getParentModule();
+  auto protocolModule = getProtocol()->getParentModule();
+  if (extensionModule->isSameModuleLookingThroughOverlays(protocolModule)) {
+    return false;
+  }
+
+  auto conformingTypeDecl =
+      ConformingType->getNominalOrBoundGenericNominal();
+  if (conformingTypeDecl) {
+    auto conformingTypeModule = conformingTypeDecl->getParentModule();
+    if (extensionModule->
+        isSameModuleLookingThroughOverlays(conformingTypeModule)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 GenericEnvironment *ProtocolConformance::getGenericEnvironment() const {
   switch (getKind()) {
   case ProtocolConformanceKind::Inherited:

lib/AST/TypeRepr.cpp

@@ -119,11 +119,11 @@ TypeRepr *TypeRepr::getWithoutParens() const {
   return repr;
 }
 
-SourceLoc TypeRepr::findUncheckedAttrLoc() const {
+SourceLoc TypeRepr::findAttrLoc(TypeAttrKind kind) const {
   auto typeRepr = this;
   while (auto attrTypeRepr = dyn_cast<AttributedTypeRepr>(typeRepr)) {
-    if (attrTypeRepr->getAttrs().has(TAK_unchecked)) {
-      return attrTypeRepr->getAttrs().getLoc(TAK_unchecked);
+    if (attrTypeRepr->getAttrs().has(kind)) {
+      return attrTypeRepr->getAttrs().getLoc(kind);
     }
 
     typeRepr = attrTypeRepr->getTypeRepr();

lib/ClangImporter/ImportDecl.cpp

@@ -7094,7 +7094,7 @@ void SwiftDeclConverter::importObjCProtocols(
       inheritedTypes.push_back(
         InheritedEntry(
           TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()),
-          /*isUnchecked=*/false));
+          /*isUnchecked=*/false, /*isRetroactive=*/false));
     }
   }
 

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -735,7 +735,8 @@ class InheritedProtocolCollector {
     // Create a synthesized ExtensionDecl for the conformance.
     ASTContext &ctx = M->getASTContext();
     auto inherits = ctx.AllocateCopy(llvm::makeArrayRef(InheritedEntry(
-        TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()), isUnchecked)));
+        TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()), isUnchecked,
+        /*isRetroactive=*/false)));
     auto extension =
         ExtensionDecl::create(ctx, SourceLoc(), nullptr, inherits,
                               nominal->getModuleScopeContext(), nullptr);

lib/Sema/TypeCheckConcurrency.cpp

@@ -5145,7 +5145,7 @@ ProtocolConformance *GetImplicitSendableRequest::evaluate(
       // FIXME: This is a hack--we should give conformances real availability.
       auto inherits = ctx.AllocateCopy(makeArrayRef(
           InheritedEntry(TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()),
-                         /*isUnchecked*/true)));
+                         /*isUnchecked*/true, /*isRetroactive=*/false)));
       // If you change the use of AtLoc in the ExtensionDecl, make sure you
       // update isNonSendableExtension() in ASTPrinter.
       auto extension = ExtensionDecl::create(ctx, attrMakingUnavailable->AtLoc,