AST: Remove some usages of SubstFlags::PreservePackExpansionLevel

Author: slavapestov

include/swift/SIL/SILCloner.h

@@ -196,8 +196,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
         // If we found a type containing a local archetype, substitute
         // open existentials throughout the substitution map.
         Subs = Subs.subst(QueryTypeSubstitutionMapOrIdentity{LocalArchetypeSubs},
-                          MakeAbstractConformanceForGenericType(),
-                          SubstFlags::PreservePackExpansionLevel);
+                          MakeAbstractConformanceForGenericType());
       }
     }
 
@@ -221,8 +220,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
       Builder.getModule(),
       QueryTypeSubstitutionMapOrIdentity{LocalArchetypeSubs},
       MakeAbstractConformanceForGenericType(),
-      CanGenericSignature(),
-      SubstFlags::PreservePackExpansionLevel);
+      CanGenericSignature());
   }
   SILType getOpType(SILType Ty) {
     Ty = getTypeInClonedContext(Ty);
@@ -241,8 +239,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
 
     return ty.subst(
       QueryTypeSubstitutionMapOrIdentity{LocalArchetypeSubs},
-      MakeAbstractConformanceForGenericType(),
-      SubstFlags::PreservePackExpansionLevel
+      MakeAbstractConformanceForGenericType()
     )->getCanonicalType();
   }
 
@@ -355,8 +352,7 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
         conformance.subst(ty,
                           QueryTypeSubstitutionMapOrIdentity{
                                                         LocalArchetypeSubs},
-                          MakeAbstractConformanceForGenericType(),
-                          SubstFlags::PreservePackExpansionLevel);
+                          MakeAbstractConformanceForGenericType());
     }
 
     return asImpl().remapConformance(getASTTypeInClonedContext(ty),

lib/AST/ASTMangler.cpp

@@ -653,13 +653,14 @@ std::string ASTMangler::mangleAutoDiffGeneratedDeclaration(
 static Type getTypeForDWARFMangling(Type t) {
   return t.subst(
     [](SubstitutableType *t) -> Type {
-      if (isa<GenericTypeParamType>(t))
-        return t->getCanonicalType();
-      return t;
+      if (isa<GenericTypeParamType>(t) &&
+          cast<GenericTypeParamType>(t)->isParameterPack()) {
+        return PackType::getSingletonPackExpansion(t->getCanonicalType());
+      }
+      return t->getCanonicalType();
     },
     MakeAbstractConformanceForGenericType(),
-    SubstFlags::AllowLoweredTypes |
-    SubstFlags::PreservePackExpansionLevel);
+    SubstFlags::AllowLoweredTypes);
 }
 
 std::string ASTMangler::mangleTypeForDebugger(Type Ty, GenericSignature sig) {

lib/AST/RequirementEnvironment.cpp

@@ -43,6 +43,13 @@ RequirementEnvironment::RequirementEnvironment(
   auto concreteType = conformanceDC->getSelfInterfaceType();
   auto conformanceSig = conformanceDC->getGenericSignatureOfContext();
 
+  auto conformanceToWitnessThunkGenericParamFn = [&](GenericTypeParamType *genericParam)
+      -> GenericTypeParamType * {
+    return GenericTypeParamType::get(genericParam->isParameterPack(),
+                                     genericParam->getDepth() + (covariantSelf ? 1 : 0),
+                                     genericParam->getIndex(), ctx);
+  };
+
   // This is a substitution function from the generic parameters of the
   // conforming type to the witness thunk environment.
   //
@@ -53,25 +60,20 @@ RequirementEnvironment::RequirementEnvironment(
   // This is a raw function rather than a substitution map because we need to
   // keep generic parameters as generic, even if the conformanceSig (the best
   // way to create the substitution map) equates them to concrete types.
-  auto conformanceToWitnessThunkTypeFn = [&](SubstitutableType *type) {
+  auto conformanceToWitnessThunkTypeFn = [&](SubstitutableType *type) -> Type {
     auto *genericParam = cast<GenericTypeParamType>(type);
-    if (covariantSelf) {
-      return GenericTypeParamType::get(genericParam->isParameterPack(),
-                                       genericParam->getDepth() + 1,
-                                       genericParam->getIndex(), ctx);
-    }
+    auto t = conformanceToWitnessThunkGenericParamFn(genericParam);
+    if (t->isParameterPack())
+      return PackType::getSingletonPackExpansion(t);
 
-    return GenericTypeParamType::get(genericParam->isParameterPack(),
-                                     genericParam->getDepth(),
-                                     genericParam->getIndex(), ctx);
+    return t;
   };
   auto conformanceToWitnessThunkConformanceFn =
       MakeAbstractConformanceForGenericType();
 
   auto substConcreteType = concreteType.subst(
       conformanceToWitnessThunkTypeFn,
-      conformanceToWitnessThunkConformanceFn,
-      SubstFlags::PreservePackExpansionLevel);
+      conformanceToWitnessThunkConformanceFn);
 
   // Calculate the depth at which the requirement's generic parameters
   // appear in the witness thunk signature.
@@ -168,9 +170,8 @@ RequirementEnvironment::RequirementEnvironment(
   // Now, add all generic parameters from the conforming type.
   if (conformanceSig) {
     for (auto param : conformanceSig.getGenericParams()) {
-      auto substParam = Type(param).subst(conformanceToWitnessThunkTypeFn,
-                                          conformanceToWitnessThunkConformanceFn);
-      genericParamTypes.push_back(substParam->castTo<GenericTypeParamType>());
+      auto substParam = conformanceToWitnessThunkGenericParamFn(param);
+      genericParamTypes.push_back(substParam);
     }
   }
 

lib/AST/TypeSubstitution.cpp

@@ -55,7 +55,13 @@ QueryTypeSubstitutionMapOrIdentity::operator()(SubstitutableType *type) const {
   auto known = substitutions.find(key);
   if (known != substitutions.end() && known->second)
     return known->second;
-  
+
+  if (isa<PackArchetypeType>(type) ||
+      (isa<GenericTypeParamType>(type) &&
+       cast<GenericTypeParamType>(type)->isParameterPack())) {
+    return PackType::getSingletonPackExpansion(type);
+  }
+
   return type;
 }