[ASTMangler] Do not crash when mangling a retroactive conformance

Author: theblixguy

lib/AST/ASTMangler.cpp

@@ -1388,7 +1388,7 @@ void ASTMangler::appendRetroactiveConformances(Type type) {
     module = Mod ? Mod : nominal->getModuleContext();
     subMap = type->getContextSubstitutionMap(module, nominal);
   }
-  
+
   appendRetroactiveConformances(subMap, module);
 }
 
@@ -2528,7 +2528,7 @@ ASTMangler::appendProtocolConformance(const ProtocolConformance *conformance) {
 
   auto conformingType = conformance->getType();
   appendType(conformingType->getCanonicalType());
-  
+
   appendProtocolName(conformance->getProtocol());
 
   bool needsModule = true;
@@ -2649,6 +2649,10 @@ void ASTMangler::appendDependentProtocolConformance(
 void ASTMangler::appendConcreteProtocolConformance(
                                       const ProtocolConformance *conformance) {
   auto module = conformance->getDeclContext()->getParentModule();
+  if (!CurGenericSignature && conformance->getGenericSignature()) {
+    CurGenericSignature =
+        conformance->getGenericSignature()->getCanonicalSignature();
+  }
 
   // Conforming type.
   Type conformingType = conformance->getType();
@@ -2679,7 +2683,7 @@ void ASTMangler::appendConcreteProtocolConformance(
         assert(CurGenericSignature &&
                "Need a generic signature to resolve conformance");
         auto conformanceAccessPath =
-          CurGenericSignature->getConformanceAccessPath(type, proto);
+            CurGenericSignature->getConformanceAccessPath(type, proto);
         appendDependentProtocolConformance(conformanceAccessPath);
       } else if (auto opaqueType = canType->getAs<OpaqueTypeArchetypeType>()) {
         GenericSignature opaqueSignature = opaqueType->getBoundSignature();

test/IRGen/retroactive_conformance_path.swift

@@ -0,0 +1,42 @@
+// RUN: %empty-directory(%t) 
+// RUN: %target-build-swift -module-name=test %s -o %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s
+// REQUIRES: executable_test
+// REQUIRES: CPU=arm64 || CPU=x86_64
+
+// Check that the ASTMangler does not crash when mangling a retroactive conformance
+// and also do a executable test to make sure the code works as expected.
+
+extension Result: RandomAccessCollection, BidirectionalCollection, Collection, Sequence where Success: RandomAccessCollection, Success.Index == Int {
+  public typealias Element = Result<Success.Element, Failure>
+  public typealias Index = Int
+  public var startIndex: Int {
+    switch self {
+      case .success(let array):
+        return array.startIndex
+      case .failure:
+        return 0
+    }
+  }
+   public var endIndex: Int {
+    switch self {
+      case .success(let array):
+        return array.endIndex
+      case .failure:
+        return 1
+    }
+   }
+   public subscript(position: Int) -> Result<Success.Element, Failure> {
+    switch self {
+    case .success(let array):
+      return .success(array[position])
+    case .failure(let error):
+      return .failure(error)
+    }
+   }
+}
+
+let coll: [Int] = [4, 8, 15, 16, 23, 42]
+let result: Result<[Int], Error> = .success(coll)
+// CHECK: success(15)
+print(result[2])