AST: Fix over-eager collapseSpecializedConformance()

It's possible that the conforming type is equal to the generic
conformance type, but some of the substitutions replace an
abstract conformance with a concrete one.

In this case we cannot collapse away the specialized conformance,
because we lose information that way.

Fixes <rdar://problem/40164371>.

Author: slavapestov

include/swift/AST/SubstitutionMap.h

@@ -181,6 +181,9 @@ class SubstitutionMap {
   /// Profile the substitution map, for use with LLVM's FoldingSet.
   void profile(llvm::FoldingSetNodeID &id) const;
 
+  const llvm::DenseMap<CanType, SmallVector<ProtocolConformanceRef, 1>> &
+  getConformanceMap() const { return conformanceMap; }
+  
 private:
   friend class GenericSignature;
   friend class GenericEnvironment;

lib/AST/ASTContext.cpp

@@ -1816,24 +1816,57 @@ ASTContext::getConformance(Type conformingType,
 /// that instead.
 static ProtocolConformance *collapseSpecializedConformance(
                                              Type type,
-                                             ProtocolConformance *conformance) {
+                                             ProtocolConformance *conformance,
+                                             SubstitutionList substitutions) {
   while (true) {
-    // If the conformance matches, return it.
-    if (conformance->getType()->isEqual(type))
-      return conformance;
-
     switch (conformance->getKind()) {
-    case ProtocolConformanceKind::Inherited:
-      conformance = cast<InheritedProtocolConformance>(conformance)
-                      ->getInheritedConformance();
+    case ProtocolConformanceKind::Specialized:
+      conformance = cast<SpecializedProtocolConformance>(conformance)
+                      ->getGenericConformance();
       break;
 
+    case ProtocolConformanceKind::Normal:
+    case ProtocolConformanceKind::Inherited:
+      // If the conformance matches, return it.
+      if (conformance->getType()->isEqual(type)) {
+        for (auto substitution : substitutions)
+          for (auto subConformance : substitution.getConformances())
+            if (!subConformance.isAbstract())
+              return nullptr;
+
+        return conformance;
+      }
+
+      return nullptr;
+    }
+  }
+}
+
+/// If one of the ancestor conformances already has a matching type, use
+/// that instead.
+static ProtocolConformance *collapseSpecializedConformance(
+                                             Type type,
+                                             ProtocolConformance *conformance,
+                                             const SubstitutionMap &substitutions) {
+  while (true) {
+    switch (conformance->getKind()) {
     case ProtocolConformanceKind::Specialized:
       conformance = cast<SpecializedProtocolConformance>(conformance)
                       ->getGenericConformance();
       break;
 
     case ProtocolConformanceKind::Normal:
+    case ProtocolConformanceKind::Inherited:
+      // If the conformance matches, return it.
+      if (conformance->getType()->isEqual(type)) {
+        for (auto conformances : substitutions.getConformanceMap())
+          for (auto subConformance : conformances.second)
+            if (!subConformance.isAbstract())
+              return nullptr;
+
+        return conformance;
+      }
+
       return nullptr;
     }
   }
@@ -1848,7 +1881,8 @@ ASTContext::getSpecializedConformance(Type type,
   // a prior conformance (e.g., mapping into and then out of a conformance),
   // return the existing conformance.
   if (!alreadyCheckedCollapsed) {
-    if (auto existing = collapseSpecializedConformance(type, generic)) {
+    if (auto existing = collapseSpecializedConformance(type, generic,
+                                                       substitutions)) {
       ++NumCollapsedSpecializedProtocolConformances;
       return existing;
     }
@@ -1885,7 +1919,7 @@ ASTContext::getSpecializedConformance(Type type,
   // If we are performing a substitution that would get us back to the
   // a prior conformance (e.g., mapping into and then out of a conformance),
   // return the existing conformance.
-  if (auto existing = collapseSpecializedConformance(type, generic)) {
+  if (auto existing = collapseSpecializedConformance(type, generic, subMap)) {
     ++NumCollapsedSpecializedProtocolConformances;
     return existing;
   }

validation-test/compiler_crashers_2_fixed/0168-rdar40164371.swift

@@ -0,0 +1,44 @@
+// RUN: %target-swift-frontend -emit-sil %s
+
+protocol X1 {
+  associatedtype X3 : X4
+}
+
+protocol X4 {
+  associatedtype X15
+}
+
+protocol X7 { }
+
+protocol X9 : X7 {
+  associatedtype X10 : X7
+}
+
+struct X12 : X9 {
+  typealias X10 = X12
+}
+
+struct X13<I1 : X7> : X9 {
+  typealias X10 = X13<I1>
+}
+
+struct X14<G : X4> : X4 where G.X15 : X9 {
+  typealias X15 = X13<G.X15.X10>
+}
+
+struct X17<A : X4> : X1 where A.X15 == X12 {
+  typealias X3 = X14<A>
+}
+
+struct X18 : X4 {
+  typealias X15 = X12
+}
+
+@_transparent
+func callee<T>(_: T) where T : X1 {
+  let _: T.X3.X15? = nil
+}
+
+func caller(b: X17<X18>) {
+  callee(b)
+}