GSB: Disable conditional requirement inference in protocols

If you have a pair of requirements T : P and T == G<U>, the conformance
G : P might be conditional, imposing arbitrary requirements on U.

In particular, these conditional requirements can mention arbitrary
protocols on the right hand side.

Introducing these conformance requirements during property map construction
is totally fine when building a top-level generic signature, but when
building a protocol requirement signature, things get a bit tricky.

Because of the design of the requirement machine, it is better if the set
of protocols appearing on the right hand side of conformance requirements
in another protocol (the "protocol dependencies") are known *before* we
start building the requirement signature, because we build the requirement
signatures of all protocols in a connected component of this graph
simultaneously.

Introducing conformance requirements to hithero-unseen protocols after
the graph of connected components had already been built would require
mutating it in a tricky way, and possibly merging connected components.

I didn't find any examples of protocols that rely on conditional
requirement inference in our test suite, or in the source compatibility
suite.

So for now, I'm going to try to disable this feature inside protocols.

Another argument in favor of not doing conditional requirement
inference in protocols is that we don't do the ordinary kind of requirement
inference there either. That is, the following is an error:

    protocol P {
      associatedtype T == Set<U>
      associatedtype U
    }

Unlike with an ordinary top-level generic signature, we don't infer
'U : Hashable' here. So arguably the current behavior of protocols inferring
these requirements in the case of a conditional conformance only is also
rather odd.

Author: slavapestov

lib/AST/GenericSignatureBuilder.cpp

@@ -680,6 +680,9 @@ struct GenericSignatureBuilder::Implementation {
   /// requirements.
   bool RebuildingWithoutRedundantConformances = false;
 
+  /// Whether we are building a protocol requirement signature.
+  bool BuildingProtocolRequirementSignature = false;
+
   /// A mapping of redundant explicit requirements to the best root requirement
   /// that implies them. Built by computeRedundantRequirements().
   using RedundantRequirementMap =
@@ -2313,6 +2316,11 @@ void GenericSignatureBuilder::addConditionalRequirements(
   if (Impl->RebuildingWithoutRedundantConformances)
     return;
 
+  // We do not perform requirement inference, including conditional requirement
+  // inference, inside protocols.
+  if (Impl->BuildingProtocolRequirementSignature)
+    return;
+
   // Abstract conformances don't have associated decl-contexts/modules, but also
   // don't have conditional requirements.
   if (conformance.isConcrete()) {
@@ -3399,10 +3407,12 @@ void EquivalenceClass::modified(GenericSignatureBuilder &builder) {
 }
 
 GenericSignatureBuilder::GenericSignatureBuilder(
-                               ASTContext &ctx)
+                               ASTContext &ctx,
+                               bool requirementSignature)
   : Context(ctx), Diags(Context.Diags), Impl(new Implementation) {
   if (auto *Stats = Context.Stats)
     ++Stats->getFrontendCounters().NumGenericSignatureBuilders;
+  Impl->BuildingProtocolRequirementSignature = requirementSignature;
 }
 
 GenericSignatureBuilder::GenericSignatureBuilder(
@@ -8833,7 +8843,8 @@ RequirementSignatureRequest::evaluate(Evaluator &evaluator,
   }
 
   auto buildViaGSB = [&]() {
-    GenericSignatureBuilder builder(proto->getASTContext());
+    GenericSignatureBuilder builder(proto->getASTContext(),
+                                    /*requirementSignature=*/true);
 
     // Add all of the generic parameters.
     for (auto gp : *proto->getGenericParams())

lib/AST/GenericSignatureBuilder.h

@@ -496,7 +496,8 @@ class GenericSignatureBuilder {
 
 public:
   /// Construct a new generic signature builder.
-  explicit GenericSignatureBuilder(ASTContext &ctx);
+  explicit GenericSignatureBuilder(ASTContext &ctx,
+                                   bool requirementSignature=false);
   GenericSignatureBuilder(GenericSignatureBuilder &&);
   ~GenericSignatureBuilder();
 

test/Generics/conditional_requirement_inference_in_protocol.swift

@@ -0,0 +1,18 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures 2>&1 | %FileCheck %s
+
+// CHECK-LABEL: conditional_requirement_inference_in_protocol.(file).Good@
+// CHECK-LABEL: Requirement signature: <Self where Self.T == Array<Self.U>, Self.U : Equatable>
+
+protocol Good {
+  associatedtype T : Equatable // expected-warning {{redundant conformance constraint 'Self.T' : 'Equatable'}}
+  associatedtype U : Equatable where T == Array<U> // expected-note {{conformance constraint 'Self.T' : 'Equatable' implied here}}
+}
+
+// CHECK-LABEL: conditional_requirement_inference_in_protocol.(file).Bad@
+// CHECK-LABEL: Requirement signature: <Self where Self.T == Array<Self.U>>
+
+protocol Bad {
+  associatedtype T : Equatable // expected-warning {{redundant conformance constraint 'Self.T' : 'Equatable'}}
+  associatedtype U where T == Array<U> // expected-note {{conformance constraint 'Self.T' : 'Equatable' implied here}}
+}