[IDE] Use LookUpConformanceInModule for synthesized extension requirement substitution

The extension may have requirements stating new conformance requirements
that aren't present in the underlying substitution map for the
conforming type.

rdar://152164768

Author: hamishknight

lib/IDE/IDETypeChecking.cpp

@@ -339,8 +339,11 @@ struct SynthesizedExtensionAnalyzer::Implementation {
 
         if (!BaseType->isExistentialType()) {
           // Apply any substitutions we need to map the requirements from a
-          // a protocol extension to an extension on the conforming type.
-          Req = Req.subst(subMap);
+          // a protocol extension to an extension on the conforming type. We
+          // need to lookup conformances outside of the substitution map since
+          // the extension may introduce new conformance constraints.
+          Req = Req.subst(QuerySubstitutionMap{subMap},
+                          LookUpConformanceInModule());
           if (Req.hasError()) {
             // Substitution with interface type bases can only fail
             // if a concrete type fails to conform to a protocol.
@@ -353,6 +356,14 @@ struct SynthesizedExtensionAnalyzer::Implementation {
         if (Req.getKind() != RequirementKind::Layout)
           assert(!Req.getSecondType()->hasArchetype());
 
+        // FIXME: This doesn't correctly handle conformance requirements, e.g:
+        //
+        // extension P where X: Q, X.Y == Int {}
+        //
+        // Since the archetype we have for `X` doesn't necessarily have a
+        // conformance to `Q` in the conforming type's generic environment. This
+        // results in a substitution failure for `X.Y`.
+        // https://github.com/swiftlang/swift/issues/83564
         auto *env = Target->getGenericEnvironment();
         SmallVector<Requirement, 2> subReqs;
         subReqs.push_back(

test/IDE/print_synthesized_extensions_generics.swift

@@ -85,3 +85,21 @@ extension G : P2 {}
 // CHECK:      extension P2 where Self.T.T : print_synthesized_extensions_generics.A {
 // CHECK-NEXT:   func blah()
 // CHECK-NEXT: }
+
+public protocol P3 {
+  associatedtype A
+}
+public protocol P4 {
+  associatedtype B: P3
+}
+
+public struct S1<A> {}
+
+// Make sure we don't crash. Unfortunately we don't yet correctly output these
+// though.
+extension S1: P4 where A: P4, A.B.A == A {
+  public typealias B = A.B
+}
+extension P3 where A: P4, A.B.A == A {
+  public func foo() {}
+}