Merge pull request #72316 from DougGregor/noncopyable-mangle-enum-cases

Author: DougGregor

include/swift/AST/ASTMangler.h

@@ -461,12 +461,24 @@ class ASTMangler : public Mangler {
     bool innermostTypeDecl;
     bool extension;
     std::optional<unsigned> mangledDepth; // for inverses
+    std::optional<unsigned> suppressedInnermostDepth;
   public:
     bool reachedInnermostTypeDecl() {
       bool answer = innermostTypeDecl;
       innermostTypeDecl = false;
       return answer;
     }
+
+    /// Whether inverses of the innermost declaration's generic parameters
+    /// should be suppressed.
+    ///
+    /// This makes sense only for entities that can only ever be defined
+    /// within the primary type, such as enum cases and the stored properties
+    /// of struct and class types.
+    std::optional<unsigned> getSuppressedInnermostInversesDepth() const {
+      return suppressedInnermostDepth;
+    }
+
     bool reachedExtension() const { return extension; }
     void setReachedExtension() { assert(!extension); extension = true; }
     GenericSignature getSignature() const { return sig; }

lib/AST/ASTMangler.cpp

@@ -2610,12 +2610,13 @@ void ASTMangler::appendSymbolicReference(SymbolicReferent referent) {
 static void reconcileInverses(
            SmallVector<InverseRequirement, 2> &inverses,
            GenericSignature sig,
-           std::optional<unsigned> inversesAlreadyMangledDepth) {
+           std::optional<unsigned> inversesAlreadyMangledDepth,
+           std::optional<unsigned> suppressedInnermostDepth) {
   CanGenericSignature baseSig;
   if (sig)
     baseSig = sig.getCanonicalSignature();
 
-  if (baseSig || inversesAlreadyMangledDepth)
+  if (baseSig || inversesAlreadyMangledDepth || suppressedInnermostDepth)
     llvm::erase_if(inverses, [&](InverseRequirement const& inv) -> bool {
       // Drop inverses that aren't applicable in the nested / child signature,
       // because of an added requirement.
@@ -2630,6 +2631,10 @@ static void reconcileInverses(
         if (gp->getDepth() <= limit)
           return true;
 
+      if (suppressedInnermostDepth &&
+          gp->getDepth() == *suppressedInnermostDepth)
+        return true;
+
       return false;
     });
 
@@ -3353,7 +3358,8 @@ void ASTMangler::gatherGenericSignatureParts(GenericSignature sig,
   // Process inverses relative to the base entity's signature.
   if (AllowInverses) {
     // Simplify and canonicalize inverses.
-    reconcileInverses(inverseReqs, base.getSignature(), base.getDepth());
+    reconcileInverses(inverseReqs, base.getSignature(), base.getDepth(),
+                      base.getSuppressedInnermostInversesDepth());
   } else {
     inverseReqs.clear();
   }
@@ -4654,6 +4660,31 @@ void ASTMangler::appendConstrainedExistential(Type base, GenericSignature sig,
   return appendOperator("XP");
 }
 
+/// Determine whether this declaration can only occur within the primary
+/// type definition.
+static bool canOnlyOccurInPrimaryTypeDefinition(const Decl *decl) {
+  // Enum elements always occur within the primary definition.
+  if (isa<EnumElementDecl>(decl))
+    return true;
+
+  return false;
+}
+
+/// When the immediate enclosing context of this declaration is
+/// a generic type (with its own generic parameters), return the depth of
+/// the innermost generic parameters.
+static std::optional<unsigned> getEnclosingTypeGenericDepth(const Decl *decl) {
+  auto typeDecl = dyn_cast<GenericTypeDecl>(decl->getDeclContext());
+  if (!typeDecl)
+    return std::nullopt;
+
+  auto genericParams = typeDecl->getGenericParams();
+  if (!genericParams)
+    return std::nullopt;
+
+  return genericParams->getParams().back()->getDepth();
+}
+
 ASTMangler::BaseEntitySignature::BaseEntitySignature(const Decl *decl)
     : sig(nullptr), innermostTypeDecl(true), extension(false),
       mangledDepth(std::nullopt) {
@@ -4668,12 +4699,22 @@ ASTMangler::BaseEntitySignature::BaseEntitySignature(const Decl *decl)
     case DeclKind::Enum:
     case DeclKind::Struct:
     case DeclKind::Class:
+    case DeclKind::EnumElement:
       sig = decl->getInnermostDeclContext()->getGenericSignatureOfContext();
 
       // Protocol members never mangle inverse constraints on `Self`.
       if (isa<ProtocolDecl>(decl->getDeclContext()))
         setDepth(0);
 
+      // Declarations that can only occur in the primary type definition should
+      // not mangle inverses for the generic parameters of that type definition.
+      // This allows types to introduce conditional conformances to invertible
+      // protocols without breaking ABI.
+      if (canOnlyOccurInPrimaryTypeDefinition(decl)) {
+        if (auto depth = getEnclosingTypeGenericDepth(decl))
+          suppressedInnermostDepth = depth;
+      }
+
       break;
 
     case DeclKind::TypeAlias: // FIXME: is this right? typealiases have a generic signature!
@@ -4686,7 +4727,6 @@ ASTMangler::BaseEntitySignature::BaseEntitySignature(const Decl *decl)
     case DeclKind::Module:
     case DeclKind::Param:
     case DeclKind::Macro:
-    case DeclKind::EnumElement:
     case DeclKind::Extension:
     case DeclKind::TopLevelCode:
     case DeclKind::Import:

lib/IRGen/IRGenMangler.h

@@ -401,9 +401,6 @@ class IRGenMangler : public Mangle::ASTMangler {
   }
 
   std::string mangleEnumCase(const ValueDecl *Decl) {
-    // No mangling of inverse conformances.
-    llvm::SaveAndRestore X(AllowInverses, false);
-
     beginMangling();
     appendEntity(Decl);
     appendOperator("WC");

test/IRGen/mangling_inverse_generics_evolution.swift

@@ -12,8 +12,8 @@ public protocol P: ~Copyable { }
 
 public struct CallMe<U: ~Copyable> {
   public enum Maybe<T: ~Copyable>: ~Copyable {
-    // CHECK-LABEL: @"$s4test6CallMeV5MaybeO4someyAEyx_qd__Gqd__cAGmr__lFWC"
-    // CHECK: @"$s4test6CallMeV5MaybeO4noneyAEyx_qd__GAGmr__lFWC"
+    // CHECK-LABEL: @"$s4test6CallMeV5MaybeOAARiczrlE4someyAEyx_qd__Gqd__cAGmr__lFWC"
+    // CHECK: @"$s4test6CallMeV5MaybeOAARiczrlE4noneyAEyx_qd__GAGmr__lFWC"
     case none
     case some(T)
   }