IRGen: Workaround for type substitution limitation

If a constrained extension has fewer conformance requirements
than the nominal type declaration, because some of the type
parameters of the nominal type are fixed to concrete types by
the extension, we would run into trouble because interface
type substitution does not correctly handle this case.

Applying an identity substitution map to an interface type
does not look up concrete types in the output generic
signature, so we get back a type parameter that is not valid.

getReducedType() has a hack to deal with this. I'd like to
get rid of the hack and fix interface type substitution to
do this correctly, but until then, this will do.

Fixes #76479

Author: slavapestov

lib/IRGen/GenProto.cpp

@@ -111,10 +111,24 @@ class PolymorphicConvention {
   FulfillmentMap Fulfillments;
 
   GenericSignature::RequiredProtocols getRequiredProtocols(Type t) {
+    // FIXME: We need to rework this to use archetypes instead of interface
+    // types, or fix the bad interaction between interface type substitution
+    // and concretized conformance requirements. Then we can remove the hack
+    // from getReducedType() to handle this case, and also stop calling
+    // getReducedType() here.
+    t = Generics.getReducedType(t);
+    if (!t->isTypeParameter())
+      return {};
+
     return Generics->getRequiredProtocols(t);
   }
 
   CanType getSuperclassBound(Type t) {
+    // See above.
+    t = Generics.getReducedType(t);
+    if (!t->isTypeParameter())
+      return CanType();
+
     if (auto superclassTy = Generics->getSuperclassBound(t))
       return superclassTy->getCanonicalType();
     return CanType();

test/IRGen/conditional_conformance_concretized_conformance_requirement.swift

@@ -0,0 +1,21 @@
+// RUN: %target-swift-frontend -emit-ir %s
+
+// https://github.com/swiftlang/swift/issues/76479
+
+public struct G<T> where T: P1, T.A: P1, T.A.A: P1 {}
+
+public protocol P1 {
+  associatedtype A
+}
+
+extension Int: P1 {
+  public typealias A = Int
+}
+
+public protocol P2 {
+  func f()
+}
+
+extension G: P2 where T.A == Int {
+  public func f() {}
+}