[Noncopyable] Mangle enum elements as "always in the primary definition"

For entities that must be part of the primary definition of a type,
mangle without inverses on the generic parameters of the enclosing
type. This ensures that we can adopt noncopyable on the generic
parameters without breaking the mangling of the fundamental entities
that describe the layout of the type.

Do this for enum elements first, so we don't break the mangling of
`Optional`. There will be other cases to consider as well.

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)
   }