Add a few convenience functions for inducing pack types from tuples

and lowered pack types.

The "approximate" thing is kindof a representational/testing wart.
Really, all that we care about is that we have a formal pack type
with the right shape.  (We don't *really* need a formal pack type ---
we could use anything that can represent the shape --- but we seem
to be standardizing on `PackType` for that.)  We could just use the
reduced shape for that, but for some reason I've been resisting that.
Not sure I have a compelling reason, though, and if we decide to
use reduced shapes, we can eliminate the approximate formal packs
stuff.

Inducing packs from tuple slices is a more permanently-useful thing.

Author: rjmccall

include/swift/AST/Types.h

@@ -2456,15 +2456,30 @@ BEGIN_CAN_TYPE_WRAPPER(TupleType, Type)
     return containsPackExpansionTypeImpl(*this);
   }
 
+  /// Induce a pack type from the elements of this tuple type.
+  inline CanTypeWrapper<PackType> getInducedPackType() const;
+
   /// Induce a pack type from a range of the elements of this tuple type.
   inline CanTypeWrapper<PackType>
   getInducedPackType(unsigned start, unsigned count) const;
 
+  /// Induce a formal pack type with the same shape as the elements
+  /// of this lowered tuple type, making a best effort to use the same
+  /// element types.
+  inline CanTypeWrapper<PackType>
+  getInducedApproximateFormalPackType() const;
+
 private:
   static bool containsPackExpansionTypeImpl(CanTupleType tuple);
 
+  static CanTypeWrapper<PackType>
+  getInducedPackTypeImpl(CanTupleType tuple);
+
   static CanTypeWrapper<PackType>
   getInducedPackTypeImpl(CanTupleType tuple, unsigned start, unsigned count);
+
+  static CanTypeWrapper<PackType>
+  getInducedApproximateFormalPackTypeImpl(CanTupleType tuple);
 END_CAN_TYPE_WRAPPER(TupleType, Type)
 
 /// UnboundGenericType - Represents a generic type where the type arguments have
@@ -5355,6 +5370,11 @@ class SILPackType final : public TypeBase, public llvm::FoldingSetNode,
   /// as the shape, not a SIL pack type.
   CanTypeWrapper<PackType> getReducedShape() const;
 
+  /// Construct a formal pack type with the same shape as this
+  /// lowered pack type, making a best effort to use the same element
+  /// types.
+  CanTypeWrapper<PackType> getApproximateFormalPackType() const;
+
   bool containsPackExpansionType() const;
 
   void Profile(llvm::FoldingSetNodeID &ID) const {
@@ -6841,11 +6861,20 @@ BEGIN_CAN_TYPE_WRAPPER(PackType, Type)
   }
 END_CAN_TYPE_WRAPPER(PackType, Type)
 
+inline CanPackType CanTupleType::getInducedPackType() const {
+  return getInducedPackTypeImpl(*this);
+}
+
 inline CanPackType
 CanTupleType::getInducedPackType(unsigned start, unsigned end) const {
   return getInducedPackTypeImpl(*this, start, end);
 }
 
+inline CanPackType
+CanTupleType::getInducedApproximateFormalPackType() const {
+  return getInducedApproximateFormalPackTypeImpl(*this);
+}
+
 /// PackExpansionType - The interface type of the explicit expansion of a
 /// corresponding set of variadic generic parameters.
 ///

lib/AST/ParameterPack.cpp

@@ -478,9 +478,76 @@ bool SILPackType::containsPackExpansionType() const {
   return false;
 }
 
+CanPackType
+CanTupleType::getInducedPackTypeImpl(CanTupleType tuple) {
+  return getInducedPackTypeImpl(tuple, 0, tuple->getNumElements());
+}
+
 CanPackType
 CanTupleType::getInducedPackTypeImpl(CanTupleType tuple, unsigned start, unsigned count) {
   assert(start + count <= tuple->getNumElements() && "range out of range");
   auto &ctx = tuple->getASTContext();
   return CanPackType::get(ctx, tuple.getElementTypes().slice(start, count));
 }
+
+static CanType getApproximateFormalElementType(const ASTContext &ctx,
+                                               CanType loweredEltType) {
+  CanType formalEltType = TupleType::getEmpty(ctx);
+  if (auto expansion = dyn_cast<PackExpansionType>(loweredEltType))
+    formalEltType = CanPackExpansionType::get(formalEltType,
+                                              expansion.getCountType());
+  return formalEltType;
+}
+
+template <class Collection>
+static CanPackType getApproximateFormalPackType(const ASTContext &ctx,
+                                                Collection loweredEltTypes) {
+  // Build an array of formal element types, but be lazy about it:
+  // use the original array unless we see an element type that doesn't
+  // work as a legal format type.
+  Optional<SmallVector<CanType, 4>> formalEltTypes;
+  for (auto i : indices(loweredEltTypes)) {
+    auto loweredEltType = loweredEltTypes[i];
+    bool isLegal = loweredEltType->isLegalFormalType();
+
+    // If the type isn't legal as a formal type, substitute the empty
+    // tuple type (or an invariant expansion of it over the count type).
+    CanType formalEltType = loweredEltType;
+    if (!isLegal) {
+      formalEltType = getApproximateFormalElementType(ctx, loweredEltType);
+    }
+
+    // If we're already building an array, unconditionally append to it.
+    // Otherwise, if the type isn't legal, build the array up to this
+    // point and then append.  Otherwise, we're still being lazy.
+    if (formalEltTypes) {
+      formalEltTypes->push_back(formalEltType);
+    } else if (!isLegal) {
+      formalEltTypes.emplace();
+      formalEltTypes->reserve(loweredEltTypes.size());
+      formalEltTypes->append(loweredEltTypes.begin(),
+                             loweredEltTypes.begin() + i);
+      formalEltTypes->push_back(formalEltType);
+    }
+
+    assert(isLegal || formalEltTypes.hasValue());
+  }
+
+  // Use the array we built if we made one (if we ever saw a non-legal
+  // element type).
+  if (formalEltTypes) {
+    return CanPackType::get(ctx, *formalEltTypes);
+  } else {
+    return CanPackType::get(ctx, loweredEltTypes);
+  }
+}
+
+CanPackType SILPackType::getApproximateFormalPackType() const {
+  return ::getApproximateFormalPackType(getASTContext(), getElementTypes());
+}
+
+CanPackType
+CanTupleType::getInducedApproximateFormalPackTypeImpl(CanTupleType tuple) {
+  return ::getApproximateFormalPackType(tuple->getASTContext(),
+                                        tuple.getElementTypes());
+}

lib/SILGen/SILGenPack.cpp

@@ -194,53 +194,6 @@ void SILGenFunction::emitDestroyPack(SILLocation loc, SILValue packAddr,
   }
 }
 
-static CanPackType getInducedFormalPackType(CanSILPackType packType) {
-  auto &ctx = packType->getASTContext();
-  auto loweredEltTypes = packType.getElementTypes();
-
-  // Build an array of formal element types, but be lazy about it:
-  // use the original array unless we see an element type that doesn't
-  // work as a legal format type.
-  Optional<SmallVector<CanType, 4>> formalEltTypes;
-  for (auto i : indices(loweredEltTypes)) {
-    auto loweredEltType = loweredEltTypes[i];
-    bool isLegal = loweredEltType->isLegalFormalType();
-
-    // If the type isn't legal as a formal type, substitute the empty
-    // tuple type (or an invariant expansion of it over the count type).
-    CanType formalEltType = loweredEltType;
-    if (!isLegal) {
-      formalEltType = TupleType::getEmpty(ctx);
-      if (auto expansion = dyn_cast<PackExpansionType>(loweredEltType))
-        formalEltType = CanPackExpansionType::get(formalEltType,
-                                                  expansion.getCountType());
-    }
-
-    // If we're already building an array, unconditionally append to it.
-    // Otherwise, if the type isn't legal, build the array up to this
-    // point and then append.  Otherwise, we're still being lazy.
-    if (formalEltTypes) {
-      formalEltTypes->push_back(formalEltType);
-    } else if (!isLegal) {
-      formalEltTypes.emplace();
-      formalEltTypes->reserve(loweredEltTypes.size());
-      formalEltTypes->append(loweredEltTypes.begin(),
-                             loweredEltTypes.begin() + i);
-      formalEltTypes->push_back(formalEltType);
-    }
-
-    assert(isLegal || formalEltTypes.hasValue());
-  }
-
-  // Use the array we built if we made one (if we ever saw a non-legal
-  // element type).
-  if (formalEltTypes) {
-    return CanPackType::get(ctx, *formalEltTypes);
-  } else {
-    return CanPackType::get(ctx, loweredEltTypes);
-  }
-}
-
 ManagedValue
 SILGenFunction::emitManagedPackWithCleanup(SILValue addr,
                                            CanPackType formalPackType) {
@@ -252,7 +205,7 @@ SILGenFunction::emitManagedPackWithCleanup(SILValue addr,
   // the lowered pack type.
   auto packType = addr->getType().castTo<SILPackType>();
   if (!formalPackType)
-    formalPackType = getInducedFormalPackType(packType);
+    formalPackType = packType->getApproximateFormalPackType();
 
   // Enter a cleanup for the pack.
   auto cleanup = enterDestroyPackCleanup(addr, formalPackType);