[AST] Add helper methods to GenericTypeParamType for converting a given type

parameter to and from a pack type parameter.

Author: hborla

include/swift/AST/Types.h

@@ -6172,6 +6172,14 @@ class GenericTypeParamType : public SubstitutableType {
   /// \endcode
   bool isParameterPack() const;
 
+  /// Returns a new GenericTypeParamType with the same depth and index
+  /// as this one, with the type parameter pack bit set.
+  GenericTypeParamType *asParameterPack(ASTContext &ctx) const;
+
+  /// Returns a new GenericTypeParamType with the same depth and index
+  /// as this one, removing the type parameter pack bit.
+  GenericTypeParamType *asScalar(ASTContext &ctx) const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::GenericTypeParam;

lib/AST/ASTContext.cpp

@@ -5600,20 +5600,14 @@ ASTContext::getOpenedElementSignature(CanGenericSignature baseGenericSig) {
   SmallVector<GenericTypeParamType *, 2> genericParams;
   SmallVector<Requirement, 2> requirements;
 
-  auto eraseParameterPack = [&](GenericTypeParamType *paramType) {
-    return GenericTypeParamType::get(
-        /*isParameterPack=*/false, paramType->getDepth(),
-        paramType->getIndex(), *this);
-  };
-
   for (auto paramType : baseGenericSig.getGenericParams()) {
-    genericParams.push_back(eraseParameterPack(paramType));
+    genericParams.push_back(paramType->asScalar(*this));
   }
 
   auto eraseParameterPackRec = [&](Type type) -> Type {
     return type.transformRec([&](Type t) -> Optional<Type> {
       if (auto *paramType = t->getAs<GenericTypeParamType>())
-        return Type(eraseParameterPack(paramType));
+        return Type(paramType->asScalar(*this));
       return None;
     });
   };

lib/AST/ParameterPack.cpp

@@ -55,6 +55,20 @@ bool GenericTypeParamType::isParameterPack() const {
          GenericTypeParamType::TYPE_SEQUENCE_BIT;
 }
 
+GenericTypeParamType *
+GenericTypeParamType::asParameterPack(ASTContext &ctx) const {
+  return GenericTypeParamType::get(/*isParameterPack*/true,
+                                   getDepth(), getIndex(),
+                                   ctx);
+}
+
+GenericTypeParamType *
+GenericTypeParamType::asScalar(ASTContext &ctx) const {
+  return GenericTypeParamType::get(/*isParameterPack*/false,
+                                   getDepth(), getIndex(),
+                                   ctx);
+}
+
 /// G<{X1, ..., Xn}, {Y1, ..., Yn}>... => {G<X1, Y1>, ..., G<Xn, Yn>}...
 PackExpansionType *PackExpansionType::expand() {
   auto countType = getCountType();
@@ -278,4 +292,4 @@ unsigned ParameterList::getOrigParamIndex(SubstitutionMap subMap,
   subMap.dump(llvm::errs());
   dump(llvm::errs());
   abort();
-}
+}

lib/Sema/CSApply.cpp

@@ -7103,9 +7103,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
           if (!genericParam || !genericParam->isParameterPack())
             return type;
 
-          auto param = GenericTypeParamType::get(/*isParameterPack*/false,
-                                                 genericParam->getDepth(),
-                                                 genericParam->getIndex(), ctx);
+          auto param = genericParam->asScalar(ctx);
           return expansion->getGenericEnvironment()->mapTypeIntoContext(param);
         });
 
@@ -7120,10 +7118,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
             return type;
 
           auto *elementParam = element->mapTypeOutOfContext()->getAs<GenericTypeParamType>();
-          auto *pack = GenericTypeParamType::get(/*isParameterPack*/true,
-                                                 elementParam->getDepth(),
-                                                 elementParam->getIndex(),
-                                                 ctx);
+          auto *pack = elementParam->asParameterPack(ctx);;
           return cs.DC->mapTypeIntoContext(pack);
         });
     auto shapeType = toExpansionType->getCountType();

lib/Sema/CSSimplify.cpp

@@ -8432,6 +8432,7 @@ ConstraintSystem::SolutionKind
 ConstraintSystem::simplifyPackElementOfConstraint(Type first, Type second,
                                                   TypeMatchOptions flags,
                                                   ConstraintLocatorBuilder locator) {
+  ASTContext &ctx = getASTContext();
   auto elementType = simplifyType(first, flags);
   auto *loc = getConstraintLocator(locator);
 
@@ -8454,10 +8455,7 @@ ConstraintSystem::simplifyPackElementOfConstraint(Type first, Type second,
       return type;
 
     auto *elementParam = element->mapTypeOutOfContext()->getAs<GenericTypeParamType>();
-    auto *pack = GenericTypeParamType::get(/*isParameterPack*/true,
-                                           elementParam->getDepth(),
-                                           elementParam->getIndex(),
-                                           this->getASTContext());
+    auto *pack = elementParam->asParameterPack(ctx);
     return this->DC->mapTypeIntoContext(pack);
   });
 

lib/Sema/PreCheckExpr.cpp

@@ -445,9 +445,7 @@ static Expr *getPackExpansion(DeclContext *dc, Expr *expr, SourceLoc opLoc) {
                 if (!genericParam || !genericParam->isParameterPack())
                   return type;
 
-                return GenericTypeParamType::get(/*isParameterPack*/false,
-                                                 genericParam->getDepth(),
-                                                 genericParam->getIndex(), ctx);
+                return genericParam->asScalar(ctx);
               });
 
           // Map the element interface type into the context of the opened