Sema: Re-introduce the hack for re-using generic signature of extended protocol

In Swift 5.10 if you wrote `extension Foo {}` for some protocol Foo,
the extension would always re-use the generic signature of Foo, which
is <Self where Self: Foo>. In Swift 6 this no longer works because Foo
might be ~Copyable, in which case `extension Foo {}` adds default
requirements, so we changed GenericSignatureRequest to just always
build a new signature if we're given an extension.

However, to avoid a request cycle with a code example that really should
have never worked at all, I'm re-introducing the hack for re-using the
signature.

Fixes rdar://problem/129540617.

Author: slavapestov

lib/Sema/TypeCheckGeneric.cpp

@@ -815,6 +815,25 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
 
     auto *extendedNominal = ext->getExtendedNominal();
 
+    // Avoid building a generic signature if we have an unconstrained protocol
+    // extension of a protocol that does not suppress conformance to ~Copyable
+    // or ~Escapable. This avoids a request cycle when referencing a protocol
+    // extension type alias via an unqualified name from a `where` clause on
+    // the protocol.
+    if (auto *proto = dyn_cast<ProtocolDecl>(extendedNominal)) {
+      if (extraReqs.empty() &&
+          !ext->getTrailingWhereClause()) {
+        InvertibleProtocolSet protos;
+        for (auto *inherited : proto->getAllInheritedProtocols()) {
+          if (auto kind = inherited->getInvertibleProtocolKind())
+            protos.insert(*kind);
+        }
+
+        if (protos == InvertibleProtocolSet::allKnown())
+          return extendedNominal->getGenericSignatureOfContext();
+      }
+    }
+
     if (isa<BuiltinTupleDecl>(extendedNominal)) {
       genericParams = ext->getGenericParams();
     } else {

test/Generics/rdar123013710.swift

@@ -15,7 +15,7 @@ extension Never: Q, P { // expected-note 2{{through reference here}}
    public static func f() -> Any? { nil }
 }
 
-extension Q { // expected-note {{through reference here}}
-   public var b: Never { fatalError() } // expected-note 4{{through reference here}}
+extension Q {
+   public var b: Never { fatalError() } // expected-note {{through reference here}}
 }
 

test/NameLookup/protocol_extension_where_clause.swift

@@ -28,4 +28,15 @@ extension P1 where Self: A {
 // This is terrible and we should ban it some day
 extension P1 where Self: A, B: Hashable {
   func h(_: Set<B>) {}
+}
+
+// This is also terrible and we should ban it
+public protocol P3 {
+  associatedtype A
+}
+
+public protocol P4: P3 where A == B {}
+
+extension P4 {
+  public typealias B = String
 }