RequirementMachine: Better error recovery from invalid protocol inheritance clauses

getInheritedProtocols() skips type resolution and directly resolves
TypeReprs to TypeDecls.

On the other hand, when building a protocol requirement signature,
we use type resolution to resolve inheritance clause entries so
that we can properly support parameterized protocol types, and
protocol compositions that contain classes.

Since a TypeRepr with an invalid sub-component resolves to an
ErrorType, this meant that in invalid code, the first list of
protocols might contain protocols that don't appear in the second.

This broke rewrite system invariants. Fix this by checking if
type resolution failed when building the requirement signature of
a protocol, and if so, also look at getInheritedProtocols().

Fixes #61020.

Author: slavapestov

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -724,10 +724,28 @@ StructuralRequirementsRequest::evaluate(Evaluator &evaluator,
 
   auto selfTy = proto->getSelfInterfaceType();
 
+  unsigned errorCount = errors.size();
   realizeInheritedRequirements(proto, selfTy,
                                /*inferRequirements=*/false,
                                result, errors);
 
+  if (errors.size() > errorCount) {
+    // Add requirements from inherited protocols, which are obtained via
+    // getDirectlyInheritedNominalTypeDecls(). Normally this duplicates
+    // the information found in the resolved types from the inheritance
+    // clause, except when type resolution fails and returns an ErrorType.
+    //
+    // For example, in 'protocol P: Q & Blah', where 'Blah' does not exist,
+    // the type 'Q & Blah' resolves to an ErrorType, while the simpler
+    // mechanism in getDirectlyInheritedNominalTypeDecls() still finds 'Q'.
+    for (auto *inheritedProto : proto->getInheritedProtocols()) {
+      result.push_back({
+          Requirement(RequirementKind::Conformance,
+                      selfTy, inheritedProto->getDeclaredInterfaceType()),
+          SourceLoc(), /*wasInferred=*/false});
+    }
+  }
+
   // Add requirements from the protocol's own 'where' clause.
   WhereClauseOwner(proto).visitRequirements(TypeResolutionStage::Structural,
       [&](const Requirement &req, RequirementRepr *reqRepr) {

test/Generics/issue-61020.swift

@@ -0,0 +1,15 @@
+// RUN: %target-typecheck-verify-swift -debug-generic-signatures 2>&1 | %FileCheck %s
+
+protocol Base<T> {
+  associatedtype T
+}
+
+// CHECK-LABEL: .Derived@
+// CHECK-NEXT: Requirement signature: <Self where Self : Base>
+protocol Derived: Base & DoesNotExist { // expected-error {{cannot find type 'DoesNotExist' in scope}}
+  func position(_: T)
+}
+
+// CHECK-LABEL: .OtherDerived@
+// CHECK-NEXT: Requirement signature: <Self where Self : Base>
+protocol OtherDerived: Base<DoesNotExist> {} // expected-error {{cannot find type 'DoesNotExist' in scope}}