[RequirementMachine] Add a generic signature query that returns the

reduced shape of a given type parameter pack.

Author: hborla

include/swift/AST/GenericSignature.h

@@ -419,6 +419,13 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// Lookup a nested type with the given name within this type parameter.
   TypeDecl *lookupNestedType(Type type, Identifier name) const;
 
+  /// Returns the shape equivalence class of the given type parameter.
+  ///
+  /// \param type The type parameter to compute the reduced shape for.
+  /// Only type parameter packs have a shape, including dependent members
+  /// whose root generic parameter is a pack.
+  Type getReducedShape(Type type) 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

@@ -534,6 +534,11 @@ GenericSignatureImpl::lookupNestedType(Type type, Identifier name) const {
   return getRequirementMachine()->lookupNestedType(type, name);
 }
 
+Type
+GenericSignatureImpl::getReducedShape(Type type) const {
+  return getRequirementMachine()->getReducedShape(type);
+}
+
 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,6 +696,27 @@ RequirementMachine::lookupNestedType(Type depType, Identifier name) const {
   return nullptr;
 }
 
+Type RequirementMachine::getReducedShape(Type type) const {
+  if (!type->isTypeSequenceParameter())
+    return Type();
+
+  auto rootType = type->getRootGenericParam();
+  auto term = Context.getMutableTermForType(rootType->getCanonicalType(),
+                                            /*proto=*/nullptr);
+
+  // Append the 'shape' symbol to the term.
+  term.add(Symbol::forShape(Context));
+
+  System.simplify(term);
+  verify(term);
+
+  // Remove the 'shape' symbol from the term.
+  assert(term.back().getKind() == Symbol::Kind::Shape);
+  MutableTerm reducedTerm(term.begin(), term.end() - 1);
+
+  return Map.getTypeForTerm(reducedTerm, getGenericParams());
+}
+
 void RequirementMachine::verify(const MutableTerm &term) const {
 #ifndef NDEBUG
   // If the term is in the generic parameter domain, ensure we have a valid

lib/AST/RequirementMachine/RequirementMachine.h

@@ -160,6 +160,8 @@ class RequirementMachine final {
   ConformancePath getConformancePath(Type type, ProtocolDecl *protocol);
   TypeDecl *lookupNestedType(Type depType, Identifier name) const;
 
+  Type getReducedShape(Type type) const;
+
   llvm::DenseMap<const ProtocolDecl *, RequirementSignature>
   computeMinimalProtocolRequirements();