Merge pull request swiftlang#36047 from slavapestov/gsb-minimal-requirement-source-fix

GSB: Fix getMinimalConformanceSource() for top-level requirements in a requirement signature

Author: slavapestov

lib/AST/GenericSignatureBuilder.cpp

@@ -820,6 +820,19 @@ const RequirementSource *RequirementSource::getMinimalConformanceSource(
     switch (source->kind) {
     case ProtocolRequirement:
     case InferredProtocolRequirement: {
+      // Special handling for top-level requirement signature requirements;
+      // pretend the root type is the subject type as written in the
+      // protocol, and not 'Self', so that we can consider this requirement
+      // self-derived if it depends on one of the conformances that make
+      // the root type valid.
+      if (requirementSignatureSelfProto) {
+        if (source->getProtocolDecl() == requirementSignatureSelfProto &&
+            source->parent->kind == RequirementSource::RequirementSignatureSelf) {
+          rootType = source->getAffectedType();
+          return false;
+        }
+      }
+
       // Note that we've seen a protocol requirement.
       sawProtocolRequirement = true;
 
@@ -2144,37 +2157,40 @@ void EquivalenceClass::dump(llvm::raw_ostream &out,
   }, [&]() {
     out << ", ";
   });
-  out << "\nConformances:";
-  interleave(conformsTo,
-             [&](const std::pair<
-                        ProtocolDecl *,
-                        std::vector<Constraint<ProtocolDecl *>>> &entry) {
-               out << entry.first->getNameStr();
-             },
-             [&] { out << ", "; });
-  out << "\nSame-type constraints:";
-  llvm::interleave(
-      sameTypeConstraints,
-      [&](const Constraint<Type> &constraint) {
-        out << "\n  " << constraint.getSubjectDependentType({})
-            << " == " << constraint.value;
+  out << "\n";
+  out << "Conformance constraints:\n";
+  for (auto entry : conformsTo) {
+    out << "  " << entry.first->getNameStr() << "\n";
+    for (auto constraint : entry.second) {
+      constraint.source->dump(out, &builder->getASTContext().SourceMgr, 4);
+      if (constraint.source->isDerivedRequirement())
+        out << " [derived]";
+      out << "\n";
+    }
+  }
+
+  out << "Same-type constraints:\n";
+  for (auto constraint : sameTypeConstraints) {
+    out << "  " << constraint.getSubjectDependentType({})
+        << " == " << constraint.value << "\n";
+    constraint.source->dump(out, &builder->getASTContext().SourceMgr, 4);
+    if (constraint.source->isDerivedRequirement())
+      out << " [derived]";
+    out << "\n";
+  }
 
-        if (constraint.source->isDerivedRequirement())
-          out << " [derived]";
-      },
-      [&] { out << ", "; });
   if (concreteType)
-    out << "\nConcrete type: " << concreteType.getString();
+    out << "Concrete type: " << concreteType.getString() << "\n";
   if (superclass)
-    out << "\nSuperclass: " << superclass.getString();
+    out << "Superclass: " << superclass.getString() << "\n";
   if (layout)
-    out << "\nLayout: " << layout.getString();
+    out << "Layout: " << layout.getString() << "\n";
 
   if (!delayedRequirements.empty()) {
-    out << "\nDelayed requirements:";
+    out << "Delayed requirements:\n";
     for (const auto &req : delayedRequirements) {
-      out << "\n  ";
       req.dump(out);
+      out << "\n";
     }
   }
 

test/Generics/sr13850.swift

@@ -0,0 +1,27 @@
+// RUN: %target-typecheck-verify-swift -debug-generic-signatures 2>&1 | %FileCheck %s
+
+// https://bugs.swift.org/browse/SR-13850
+
+// CHECK: Requirement signature: <Self where Self.A : P2>
+protocol P1 {
+  associatedtype A: P2
+}
+
+// CHECK: Requirement signature: <Self>
+protocol P2 {
+  associatedtype A
+}
+
+// Neither one of 'P3', 'P4' or 'f()' should have diagnosed
+// redundant conformance requirements.
+
+// CHECK: Requirement signature: <Self where Self : P2, Self == Self.A.A, Self.A : P1>
+protocol P3 : P2 where Self.A: P1, Self.A.A == Self { }
+
+// CHECK: Requirement signature: <Self where Self.X : P2, Self.X == Self.X.A.A, Self.X.A : P1>
+protocol P4 {
+  associatedtype X where X : P2, X.A: P1, X.A.A == X
+}
+
+// CHECK: Generic signature: <T where T : P2, T == T.A.A, T.A : P1>
+func f<T : P2>(_: T) where T.A : P1, T.A.A == T { }