[RequirementMachine] Add a generic signature query that determines whether

two type parameter packs have the same shape.

Author: hborla

include/swift/AST/GenericSignature.h

@@ -426,6 +426,10 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// whose root generic parameter is a pack.
   Type getReducedShape(Type type) const;
 
+  /// Returns \c true if the given type parameter packs are in
+  /// the same shape equivalence class.
+  bool haveSameShape(Type type1, Type type2) const;
+
   /// Get the ordinal of a generic parameter in this generic signature.
   ///
   /// For example, if you have a generic signature for a nested context like:

lib/AST/GenericSignature.cpp

@@ -539,6 +539,11 @@ GenericSignatureImpl::getReducedShape(Type type) const {
   return getRequirementMachine()->getReducedShape(type);
 }
 
+bool
+GenericSignatureImpl::haveSameShape(Type type1, Type type2) const {
+  return getRequirementMachine()->haveSameShape(type1, type2);
+}
+
 unsigned GenericParamKey::findIndexIn(
                       TypeArrayView<GenericTypeParamType> genericParams) const {
   // For depth 0, we have random access. We perform the extra checking so that

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -696,9 +696,9 @@ RequirementMachine::lookupNestedType(Type depType, Identifier name) const {
   return nullptr;
 }
 
-Type RequirementMachine::getReducedShape(Type type) const {
-  if (!type->isTypeSequenceParameter())
-    return Type();
+MutableTerm
+RequirementMachine::getReducedShapeTerm(Type type) const {
+  assert(type->isTypeSequenceParameter());
 
   auto rootType = type->getRootGenericParam();
   auto term = Context.getMutableTermForType(rootType->getCanonicalType(),
@@ -714,7 +714,22 @@ Type RequirementMachine::getReducedShape(Type type) const {
   assert(term.back().getKind() == Symbol::Kind::Shape);
   MutableTerm reducedTerm(term.begin(), term.end() - 1);
 
-  return Map.getTypeForTerm(reducedTerm, getGenericParams());
+  return reducedTerm;
+}
+
+Type RequirementMachine::getReducedShape(Type type) const {
+  if (!type->isTypeSequenceParameter())
+    return Type();
+
+  return Map.getTypeForTerm(getReducedShapeTerm(type),
+                            getGenericParams());
+}
+
+bool RequirementMachine::haveSameShape(Type type1, Type type2) const {
+  auto term1 = getReducedShapeTerm(type1);
+  auto term2 = getReducedShapeTerm(type2);
+
+  return term1 == term2;
 }
 
 void RequirementMachine::verify(const MutableTerm &term) const {

lib/AST/RequirementMachine/RequirementMachine.h

@@ -160,8 +160,14 @@ class RequirementMachine final {
   ConformancePath getConformancePath(Type type, ProtocolDecl *protocol);
   TypeDecl *lookupNestedType(Type depType, Identifier name) const;
 
+private:
+  MutableTerm getReducedShapeTerm(Type type) const;
+
+public:
   Type getReducedShape(Type type) const;
 
+  bool haveSameShape(Type type1, Type type2) const;
+
   llvm::DenseMap<const ProtocolDecl *, RequirementSignature>
   computeMinimalProtocolRequirements();