Merge pull request #72157 from DougGregor/more-inverse-mangling-suppression

[Noncopyable generics] Suppress inverse conformance mangling for more symbols

Author: DougGregor

lib/IRGen/IRGenMangler.cpp

@@ -214,6 +214,9 @@ std::string IRGenMangler::mangleProtocolConformanceDescriptor(
 
 std::string IRGenMangler::mangleProtocolConformanceDescriptorRecord(
                                  const RootProtocolConformance *conformance) {
+  llvm::SaveAndRestore X(AllowInverses,
+                         inversesAllowedIn(conformance->getDeclContext()));
+
   beginMangling();
   appendProtocolConformance(conformance);
   appendOperator("Hc");
@@ -222,6 +225,9 @@ std::string IRGenMangler::mangleProtocolConformanceDescriptorRecord(
 
 std::string IRGenMangler::mangleProtocolConformanceInstantiationCache(
                                  const RootProtocolConformance *conformance) {
+  llvm::SaveAndRestore X(AllowInverses,
+                         inversesAllowedIn(conformance->getDeclContext()));
+
   beginMangling();
   if (isa<NormalProtocolConformance>(conformance)) {
     appendProtocolConformance(conformance);
@@ -511,3 +517,17 @@ IRGenMangler::appendExtendedExistentialTypeShape(CanGenericSignature genSig,
   appendOperator(genSig ? "XG" : "Xg");
 }
 
+std::string
+IRGenMangler::mangleConformanceSymbol(Type type,
+                                      const ProtocolConformance *Conformance,
+                                      const char *Op) {
+llvm::SaveAndRestore X(AllowInverses,
+                       inversesAllowedIn(Conformance->getDeclContext()));
+
+  beginMangling();
+  if (type)
+    appendType(type, nullptr);
+  appendProtocolConformance(Conformance);
+  appendOperator(Op);
+  return finalize();
+}

lib/IRGen/IRGenMangler.h

@@ -46,6 +46,9 @@ class IRGenMangler : public Mangle::ASTMangler {
   IRGenMangler() { }
 
   std::string mangleDispatchThunk(const FuncDecl *func) {
+    // Dispatch thunks do not mangle inverse conformances.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginMangling();
     appendEntity(func);
     appendOperator("Tj");
@@ -55,6 +58,9 @@ class IRGenMangler : public Mangle::ASTMangler {
   std::string mangleDerivativeDispatchThunk(
       const AbstractFunctionDecl *func,
       AutoDiffDerivativeFunctionIdentifier *derivativeId) {
+    // Dispatch thunks do not mangle inverse conformances.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginManglingWithAutoDiffOriginalFunction(func);
     auto kind = Demangle::getAutoDiffFunctionKind(derivativeId->getKind());
     auto *resultIndices =
@@ -71,13 +77,19 @@ class IRGenMangler : public Mangle::ASTMangler {
 
   std::string mangleConstructorDispatchThunk(const ConstructorDecl *ctor,
                                              bool isAllocating) {
+    // Dispatch thunks do not mangle inverse conformances.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginMangling();
     appendConstructorEntity(ctor, isAllocating);
     appendOperator("Tj");
     return finalize();
   }
 
   std::string mangleMethodDescriptor(const FuncDecl *func) {
+    // Method descriptors do not mangle inverse conformances.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginMangling();
     appendEntity(func);
     appendOperator("Tq");
@@ -87,6 +99,9 @@ class IRGenMangler : public Mangle::ASTMangler {
   std::string mangleDerivativeMethodDescriptor(
       const AbstractFunctionDecl *func,
       AutoDiffDerivativeFunctionIdentifier *derivativeId) {
+    // Method descriptors do not mangle inverse conformances.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginManglingWithAutoDiffOriginalFunction(func);
     auto kind = Demangle::getAutoDiffFunctionKind(derivativeId->getKind());
     auto *resultIndices =
@@ -103,6 +118,9 @@ class IRGenMangler : public Mangle::ASTMangler {
 
   std::string mangleConstructorMethodDescriptor(const ConstructorDecl *ctor,
                                                 bool isAllocating) {
+    // Method descriptors do not mangle inverse conformances.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginMangling();
     appendConstructorEntity(ctor, isAllocating);
     appendOperator("Tq");
@@ -327,6 +345,10 @@ class IRGenMangler : public Mangle::ASTMangler {
     // among the type descriptors of different protocols.
     llvm::SaveAndRestore<bool> optimizeProtocolNames(OptimizeProtocolNames,
                                                      false);
+
+    // No mangling of inverse conformances inside protocols.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginMangling();
     bool isAssocTypeAtDepth = false;
     (void)appendAssocType(
@@ -341,6 +363,9 @@ class IRGenMangler : public Mangle::ASTMangler {
       const ProtocolDecl *proto,
       CanType subject,
       const ProtocolDecl *requirement) {
+    // No mangling of inverse conformances inside protocols.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginMangling();
     appendAnyGenericType(proto);
     if (isa<GenericTypeParamType>(subject)) {
@@ -357,6 +382,9 @@ class IRGenMangler : public Mangle::ASTMangler {
   std::string mangleBaseConformanceDescriptor(
       const ProtocolDecl *proto,
       const ProtocolDecl *requirement) {
+    // No mangling of inverse conformances inside protocols.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginMangling();
     appendAnyGenericType(proto);
     appendProtocolName(requirement);
@@ -368,6 +396,9 @@ class IRGenMangler : public Mangle::ASTMangler {
       const ProtocolDecl *proto,
       CanType subject,
       const ProtocolDecl *requirement) {
+    // No mangling of inverse conformances inside protocols.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginMangling();
     appendAnyGenericType(proto);
     bool isFirstAssociatedTypeIdentifier = true;
@@ -385,20 +416,27 @@ class IRGenMangler : public Mangle::ASTMangler {
                                     const RootProtocolConformance *conformance);
 
   std::string manglePropertyDescriptor(const AbstractStorageDecl *storage) {
+    llvm::SaveAndRestore X(AllowInverses, inversesAllowed(storage));
     beginMangling();
     appendEntity(storage);
     appendOperator("MV");
     return finalize();
   }
 
   std::string mangleFieldOffset(const ValueDecl *Decl) {
+    // No mangling of inverse conformances.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginMangling();
     appendEntity(Decl);
     appendOperator("Wvd");
     return finalize();
   }
 
   std::string mangleEnumCase(const ValueDecl *Decl) {
+    // No mangling of inverse conformances.
+    llvm::SaveAndRestore X(AllowInverses, false);
+
     beginMangling();
     appendEntity(Decl);
     appendOperator("WC");
@@ -716,14 +754,7 @@ class IRGenMangler : public Mangle::ASTMangler {
 
   std::string mangleConformanceSymbol(Type type,
                                       const ProtocolConformance *Conformance,
-                                      const char *Op) {
-    beginMangling();
-    if (type)
-      appendType(type, nullptr);
-    appendProtocolConformance(Conformance);
-    appendOperator(Op);
-    return finalize();
-  }
+                                      const char *Op);
 };
 
 /// Determines if the minimum deployment target's runtime demangler will not

test/IRGen/mangling_inverse_generics_evolution.swift

@@ -0,0 +1,27 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-ir -o - %s -module-name test \
+// RUN:   -enable-experimental-feature NoncopyableGenerics \
+// RUN:   -enable-experimental-feature NonescapableTypes \
+// RUN:   -parse-as-library \
+// RUN:   -enable-library-evolution \
+// RUN:   > %t/test.irgen
+
+// RUN: %FileCheck %s < %t/test.irgen
+
+public protocol P: ~Copyable { }
+
+public protocol Hello<Person>: ~Copyable {
+  // CHECK: @"$s4test5HelloP6PersonAC_AA1PTn"
+  // CHECK: @"$s6Person4test5HelloPTl" =
+  associatedtype Person: P & ~Copyable
+
+  // CHECK: @"$s4test5HelloP14favoritePerson0D0QzvrTq" =
+  var favoritePerson: Person { get }
+
+  // CHECK: @"$s4test5HelloP5greetyy6PersonQzFTq"
+  func greet(_ person: borrowing Person)
+}
+
+public struct Wrapper<T: ~Copyable> {
+  var wrapped: T { fatalError("boom") }
+}