RequirementMachine: The reduced type of a PackExpansionType has a reduced *shape* for the count type

I don't have a test case for this but it was bound to
come up eventually.

Author: slavapestov

lib/AST/GenericSignature.cpp

@@ -536,7 +536,7 @@ GenericSignatureImpl::lookupNestedType(Type type, Identifier name) const {
 
 Type
 GenericSignatureImpl::getReducedShape(Type type) const {
-  return getRequirementMachine()->getReducedShape(type);
+  return getRequirementMachine()->getReducedShape(type, getGenericParams());
 }
 
 bool

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -57,7 +57,7 @@ RequirementMachine::getLocalRequirements(
 
   GenericSignature::LocalRequirements result;
   result.anchor = Map.getTypeForTerm(term, genericParams);
-  result.packShape = getReducedShape(depType);
+  result.packShape = getReducedShape(depType, genericParams);
 
   auto *props = Map.lookUpProperties(term);
   if (!props)
@@ -365,6 +365,17 @@ Type RequirementMachine::getReducedType(
     if (!t->hasTypeParameter())
       return t;
 
+    // The reduced type of a PackExpansionType has a reduced *shape* for
+    // the count type.
+    if (auto *packExpansionType = t->getAs<PackExpansionType>()) {
+      auto reducedPattern = getReducedType(packExpansionType->getPatternType(),
+                                           genericParams);
+      auto reducedShape = packExpansionType->getCountType();
+      if (reducedShape->isParameterPack())
+        reducedShape = getReducedShape(reducedShape, genericParams);
+      return Type(PackExpansionType::get(reducedPattern, reducedShape));
+    }
+
     if (!t->isTypeParameter())
       return None;
 
@@ -727,12 +738,12 @@ RequirementMachine::getReducedShapeTerm(Type type) const {
   return reducedTerm;
 }
 
-Type RequirementMachine::getReducedShape(Type type) const {
+Type RequirementMachine::getReducedShape(Type type,
+                      TypeArrayView<GenericTypeParamType> genericParams) const {
   if (!type->isParameterPack())
     return Type();
 
-  return Map.getTypeForTerm(getReducedShapeTerm(type),
-                            getGenericParams());
+  return Map.getTypeForTerm(getReducedShapeTerm(type), genericParams);
 }
 
 bool RequirementMachine::haveSameShape(Type type1, Type type2) const {

lib/AST/RequirementMachine/RequirementMachine.h

@@ -164,7 +164,8 @@ class RequirementMachine final {
   MutableTerm getReducedShapeTerm(Type type) const;
 
 public:
-  Type getReducedShape(Type type) const;
+  Type getReducedShape(Type type,
+                       TypeArrayView<GenericTypeParamType> genericParams) const;
 
   bool haveSameShape(Type type1, Type type2) const;
 

lib/AST/Type.cpp

@@ -4684,7 +4684,18 @@ static Type substType(Type derivedType,
                              boxTy->getLayout(),
                              newSubMap);
     }
-    
+
+    if (auto packExpansionTy = dyn_cast<PackExpansionType>(type)) {
+      auto patternTy = substType(packExpansionTy->getPatternType(),
+                                 substitutions, lookupConformances, options);
+      auto countTy = substType(packExpansionTy->getCountType(),
+                               substitutions, lookupConformances, options);
+      if (auto *archetypeTy = countTy->getAs<PackArchetypeType>())
+        countTy = archetypeTy->getReducedShape();
+
+      return Type(PackExpansionType::get(patternTy, countTy)->expand());
+    }
+
     if (auto silFnTy = dyn_cast<SILFunctionType>(type)) {
       if (silFnTy->isPolymorphic())
         return None;