RequirementMachine: Split up equivalence classes with inferred concrete type

I'll clean this up, comment it and generalize it to work with protocol requirement
signatures soon. Landing this now to unblock the Linux corelibs-foundation build.

Fixes rdar://problem/89791117.

Author: slavapestov

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -243,6 +243,59 @@ static bool isCanonicalRequest(GenericSignature baseSignature,
   return true;
 }
 
+/// Hack for GenericSignatureBuilder compatibility. We might end up with a
+/// same-type requirement between type parameters where one of them has an
+/// implied concrete type requirement. In this case, split it up into two
+/// concrete type requirements.
+static bool shouldSplitConcreteEquivalenceClass(Requirement req,
+                                                GenericSignature sig) {
+  return (req.getKind() == RequirementKind::SameType &&
+          req.getSecondType()->isTypeParameter() &&
+          sig->isConcreteType(req.getSecondType()));
+}
+
+static bool shouldSplitConcreteEquivalenceClasses(GenericSignature sig) {
+  for (auto req : sig.getRequirements()) {
+    if (shouldSplitConcreteEquivalenceClass(req, sig))
+      return true;
+  }
+
+  return false;
+}
+
+static GenericSignature splitConcreteEquivalenceClasses(
+    GenericSignature sig, ASTContext &ctx) {
+  SmallVector<Requirement, 2> reqs;
+
+  for (auto req : sig.getRequirements()) {
+    if (shouldSplitConcreteEquivalenceClass(req, sig)) {
+      auto canType = sig->getSugaredType(
+        sig.getCanonicalTypeInContext(
+          req.getSecondType()));
+
+      reqs.emplace_back(RequirementKind::SameType,
+                        req.getFirstType(),
+                        canType);
+      reqs.emplace_back(RequirementKind::SameType,
+                        req.getSecondType(),
+                        canType);
+    } else {
+      reqs.push_back(req);
+    }
+  }
+
+  SmallVector<GenericTypeParamType *, 2> genericParams;
+  genericParams.append(sig.getGenericParams().begin(),
+                       sig.getGenericParams().end());
+
+  return evaluateOrDefault(
+      ctx.evaluator,
+      AbstractGenericSignatureRequestRQM{
+        /*baseSignature=*/nullptr,
+        genericParams, reqs},
+      GenericSignatureWithError()).getPointer();
+}
+
 GenericSignatureWithError
 AbstractGenericSignatureRequestRQM::evaluate(
          Evaluator &evaluator,
@@ -391,8 +444,13 @@ AbstractGenericSignatureRequestRQM::evaluate(
   auto result = GenericSignature::get(genericParams, minimalRequirements);
   auto errorFlags = machine->getErrors();
 
-  if (!errorFlags)
+  if (!errorFlags) {
+    if (shouldSplitConcreteEquivalenceClasses(result))
+      result = splitConcreteEquivalenceClasses(result, ctx);
+
+    // Check invariants.
     result.verify();
+  }
 
   return GenericSignatureWithError(result, errorFlags);
 }
@@ -543,9 +601,13 @@ InferredGenericSignatureRequestRQM::evaluate(
 
   // FIXME: Handle allowConcreteGenericParams
 
-  // Check invariants.
-  if (!errorFlags)
+  if (!errorFlags) {
+    if (shouldSplitConcreteEquivalenceClasses(result))
+      result = splitConcreteEquivalenceClasses(result, ctx);
+
+    // Check invariants.
     result.verify();
+  }
 
   return GenericSignatureWithError(result, errorFlags);
 }

test/Generics/split_concrete_equivalence_class.swift

@@ -0,0 +1,37 @@
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
+
+// CHECK-LABEL: split_concrete_equivalence_class.(file).f01@
+// CHECK-NEXT: Generic signature: <C, R where C : Collection, R : Collection, C.[Collection]SubSequence == Substring, R.[Sequence]Element == Character>
+func f01<C : Collection, R : Collection>(_: C, _: R) where C.SubSequence == Substring, C.Element == R.Element {}
+
+// CHECK-LABEL: split_concrete_equivalence_class.(file).f02@
+// CHECK-NEXT: Generic signature: <C, R where C : Collection, R : Collection, C.[Sequence]Element == Character, R.[Collection]SubSequence == Substring>
+func f02<C : Collection, R : Collection>(_: C, _: R) where R.SubSequence == Substring, C.Element == R.Element {}
+
+// CHECK-LABEL: split_concrete_equivalence_class.(file).f03@
+// CHECK-NEXT: Generic signature: <C, R where C : Collection, R : Collection, C.[Collection]SubSequence == Substring, R.[Sequence]Element == Character>
+func f03<C : Collection, R : Collection>(_: C, _: R) where C.SubSequence == Substring, C.Element == R.Element, C.Element == Character {}
+
+// CHECK-LABEL: split_concrete_equivalence_class.(file).f04@
+// CHECK-NEXT: Generic signature: <C, R where C : Collection, R : Collection, C.[Sequence]Element == Character, R.[Collection]SubSequence == Substring>
+func f04<C : Collection, R : Collection>(_: C, _: R) where R.SubSequence == Substring, C.Element == R.Element, C.Element == Character {}
+
+// CHECK-LABEL: split_concrete_equivalence_class.(file).f05@
+// CHECK-NEXT: Generic signature: <C, R where C : Collection, R : Collection, C.[Collection]SubSequence == Substring, R.[Sequence]Element == Character>
+func f05<C : Collection, R : Collection>(_: C, _: R) where C.SubSequence == Substring, C.Element == R.Element, R.Element == Character {}
+
+// CHECK-LABEL: split_concrete_equivalence_class.(file).f06@
+// CHECK-NEXT: Generic signature: <C, R where C : Collection, R : Collection, C.[Sequence]Element == Character, R.[Collection]SubSequence == Substring>
+func f06<C : Collection, R : Collection>(_: C, _: R) where R.SubSequence == Substring, C.Element == R.Element, R.Element == Character {}
+
+// CHECK-LABEL: split_concrete_equivalence_class.(file).f07@
+// CHECK-NEXT: Generic signature: <C, R where C : Collection, R : Collection, C.[Collection]SubSequence == Substring, R.[Collection]SubSequence == Substring>
+func f07<C : Collection, R : Collection>(_: C, _: R) where C.SubSequence == Substring, R.SubSequence == Substring, C.Element == R.Element {}
+
+// CHECK-LABEL: split_concrete_equivalence_class.(file).f08@
+// CHECK-NEXT: Generic signature: <C, R where C : Collection, R : Collection, C.[Collection]SubSequence == Substring, R.[Collection]SubSequence == Substring>
+func f08<C : Collection, R : Collection>(_: C, _: R) where C.SubSequence == Substring, R.SubSequence == Substring, C.Element == R.Element, C.Element == Character {}
+
+// CHECK-LABEL: split_concrete_equivalence_class.(file).f09@
+// CHECK-NEXT: Generic signature: <C, R where C : Collection, R : Collection, C.[Collection]SubSequence == Substring, R.[Collection]SubSequence == Substring>
+func f09<C : Collection, R : Collection>(_: C, _: R) where C.SubSequence == Substring, R.SubSequence == Substring, C.Element == R.Element, R.Element == Character {}