Merge pull request swiftlang#39035 from slavapestov/irgen-wrong-signature

IRGen: Mangle DWARF types with the right generic signature

Author: slavapestov

lib/AST/ASTMangler.cpp

@@ -1116,7 +1116,9 @@ void ASTMangler::appendType(Type type, const ValueDecl *forDecl) {
         if (tryMangleTypeSubstitution(tybase))
           return;
 
+        auto outerGenericSig = CurGenericSignature;
         appendAnyGenericType(decl);
+        CurGenericSignature = outerGenericSig;
         bool isFirstArgList = true;
         appendBoundGenericArgs(type, isFirstArgList);
         appendRetroactiveConformances(type);
@@ -1249,7 +1251,9 @@ void ASTMangler::appendType(Type type, const ValueDecl *forDecl) {
           appendType(GenArgs[0], forDecl);
           appendOperator("Sg");
         } else {
+          auto outerGenericSig = CurGenericSignature;
           appendAnyGenericType(Decl);
+          CurGenericSignature = outerGenericSig;
           bool isFirstArgList = true;
           appendBoundGenericArgs(type, isFirstArgList);
           appendRetroactiveConformances(type);
@@ -3224,17 +3228,6 @@ void ASTMangler::appendConcreteProtocolConformance(
                                       const ProtocolConformance *conformance) {
   auto module = conformance->getDeclContext()->getParentModule();
 
-  // It's possible that we might not have a generic signature here to get
-  // the conformance access path (for example, when mangling types for
-  // debugger). In that case, we can use the generic signature of the
-  // conformance (if it's present).
-  auto conformanceSig = conformance->getGenericSignature();
-  auto shouldUseConformanceSig = !CurGenericSignature && conformanceSig;
-  llvm::SaveAndRestore<CanGenericSignature> savedSignature(
-      CurGenericSignature, shouldUseConformanceSig
-                               ? conformanceSig.getCanonicalSignature()
-                               : CurGenericSignature);
-
   // Conforming type.
   Type conformingType = conformance->getType();
   if (conformingType->hasArchetype())

lib/IRGen/GenType.cpp

@@ -1441,9 +1441,6 @@ TypeConverter::~TypeConverter() {
 }
 
 void TypeConverter::setGenericContext(CanGenericSignature signature) {
-  if (!signature)
-    return;
-  
   CurGenericSignature = signature;
 
   // Clear the dependent type info cache since we have a new active signature

lib/IRGen/GenType.h

@@ -277,8 +277,6 @@ class GenericContextScope {
   {}
 
   ~GenericContextScope() {
-    if (!newSig)
-      return;
     assert(TC.CurGenericSignature == newSig);
     TC.setGenericContext(oldSig);
   }

lib/IRGen/IRGenDebugInfo.cpp

@@ -21,6 +21,7 @@
 #include "GenType.h"
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/Expr.h"
+#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/IRGenOptions.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ModuleLoader.h"
@@ -825,9 +826,29 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
       return MetadataTypeDeclCache.find(DbgTy.getDecl()->getName().str())
           ->getKey();
 
+    // This is a bit of a hack. We need a generic signature to use for mangling.
+    // If we started with an interface type, just use IGM.getCurGenericContext(),
+    // since callers that use interface types typically push a signature that way.
+    //
+    // Otherwise, if we have a contextual type, find an archetype and ask it for
+    // it's generic signature. The context generic signature from the IRGenModule
+    // is unlikely to be useful here.
+    GenericSignature Sig;
     Type Ty = DbgTy.getType();
-    if (Ty->hasArchetype())
+    if (Ty->hasArchetype()) {
+      Ty.findIf([&](Type t) -> bool {
+        if (auto *archetypeTy = t->getAs<PrimaryArchetypeType>()) {
+          Sig = archetypeTy->getGenericEnvironment()->getGenericSignature();
+          return true;
+        }
+
+        return false;
+      });
+
       Ty = Ty->mapTypeOutOfContext();
+    } else {
+      Sig = IGM.getCurGenericContext();
+    }
 
     // Strip off top level of type sugar (except for type aliases).
     // We don't want Optional<T> and T? to get different debug types.
@@ -852,7 +873,6 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
         IGM.getSILModule());
 
     Mangle::ASTMangler Mangler;
-    GenericSignature Sig = IGM.getCurGenericContext();
     std::string Result = Mangler.mangleTypeForDebugger(Ty, Sig);
 
     if (!Opts.DisableRoundTripDebugTypes) {

test/IRGen/retroactive_conformance_path.swift

@@ -1,5 +1,5 @@
 // RUN: %empty-directory(%t) 
-// RUN: %target-build-swift -module-name=test %s -o %t/a.out
+// RUN: %target-build-swift -module-name=test %s -o %t/a.out -requirement-machine=verify
 // RUN: %target-run %t/a.out | %FileCheck %s
 // REQUIRES: executable_test
 // REQUIRES: CPU=arm64 || CPU=x86_64

test/IRGen/retroactive_conformance_path_2.swift

@@ -0,0 +1,9 @@
+// RUN: %target-swift-frontend -emit-ir -g -primary-file %s -requirement-machine=verify
+
+public struct TestType<T: Error> { }
+
+extension Array: Error where Element: Error { }
+
+public struct GenericType<G> {
+    public func test<T>(_ value: TestType<[T]>) { }
+}