Allow a SILFunctionArgument to be a parameter pack.

We might want to record the *sequence* of parameter decls associated
with a parameter pack, but currently we're not doing that.

Author: rjmccall

include/swift/SIL/SILArgument.h

@@ -342,12 +342,14 @@ class SILFunctionArgument : public SILArgument {
       ValueOwnershipKind ownershipKind, const ValueDecl *decl = nullptr,
       bool isNoImplicitCopy = false,
       LifetimeAnnotation lifetimeAnnotation = LifetimeAnnotation::None,
-      bool isCapture = false)
+      bool isCapture = false,
+      bool isParameterPack = false)
       : SILArgument(ValueKind::SILFunctionArgument, parentBlock, type,
                     ownershipKind, decl) {
     sharedUInt32().SILFunctionArgument.noImplicitCopy = isNoImplicitCopy;
     sharedUInt32().SILFunctionArgument.lifetimeAnnotation = lifetimeAnnotation;
     sharedUInt32().SILFunctionArgument.closureCapture = isCapture;
+    sharedUInt32().SILFunctionArgument.parameterPack = isParameterPack;
   }
 
   // A special constructor, only intended for use in
@@ -373,6 +375,23 @@ class SILFunctionArgument : public SILArgument {
     sharedUInt32().SILFunctionArgument.closureCapture = newValue;
   }
 
+  /// Is this parameter a pack that corresponds to multiple
+  /// formal parameters?  (This could mean multiple ParamDecl*s,
+  /// or it could mean a ParamDecl* that's a pack expansion.)  Note
+  /// that not all lowered parameters of pack type are parameter packs:
+  /// they can be part of a single formal parameter of tuple type.
+  /// This flag indicates that the lowered parameter has a one-to-many
+  /// relationship with formal parameters.
+  ///
+  /// TODO: preserve the parameter pack references in SIL in a side table
+  /// instead of using a single bit.
+  bool isFormalParameterPack() const {
+    return sharedUInt32().SILFunctionArgument.parameterPack;
+  }
+  void setFormalParameterPack(bool isPack) {
+    sharedUInt32().SILFunctionArgument.parameterPack = isPack;
+  }
+
   LifetimeAnnotation getLifetimeAnnotation() const {
     return LifetimeAnnotation::Case(
         sharedUInt32().SILFunctionArgument.lifetimeAnnotation);
@@ -416,6 +435,7 @@ class SILFunctionArgument : public SILArgument {
     setNoImplicitCopy(arg->isNoImplicitCopy());
     setLifetimeAnnotation(arg->getLifetimeAnnotation());
     setClosureCapture(arg->isClosureCapture());
+    setFormalParameterPack(arg->isFormalParameterPack());
   }
 
   static bool classof(const SILInstruction *) = delete;

include/swift/SIL/SILNode.h

@@ -268,7 +268,8 @@ class alignas(8) SILNode :
     SHARED_FIELD(StringLiteralInst, uint32_t length);
     SHARED_FIELD(PointerToAddressInst, uint32_t alignment);
     SHARED_FIELD(SILFunctionArgument, uint32_t noImplicitCopy : 1,
-                 lifetimeAnnotation : 2, closureCapture : 1);
+                 lifetimeAnnotation : 2, closureCapture : 1,
+                 parameterPack : 1);
 
     // Do not use `_sharedUInt32_private` outside of SILNode.
   } _sharedUInt32_private;

lib/SILGen/SILGenBuilder.cpp

@@ -451,15 +451,17 @@ static ManagedValue createInputFunctionArgument(
     SILGenBuilder &B, SILType type, SILLocation loc, ValueDecl *decl = nullptr,
     bool isNoImplicitCopy = false,
     LifetimeAnnotation lifetimeAnnotation = LifetimeAnnotation::None,
-    bool isClosureCapture = false) {
+    bool isClosureCapture = false,
+    bool isFormalParameterPack = false) {
   auto &SGF = B.getSILGenFunction();
   SILFunction &F = B.getFunction();
-  assert((F.isBare() || decl) &&
+  assert((F.isBare() || isFormalParameterPack || decl) &&
          "Function arguments of non-bare functions must have a decl");
   auto *arg = F.begin()->createFunctionArgument(type, decl);
   arg->setNoImplicitCopy(isNoImplicitCopy);
   arg->setClosureCapture(isClosureCapture);
   arg->setLifetimeAnnotation(lifetimeAnnotation);
+  arg->setFormalParameterPack(isFormalParameterPack);
   switch (arg->getArgumentConvention()) {
   case SILArgumentConvention::Indirect_In_Guaranteed:
   case SILArgumentConvention::Direct_Guaranteed:
@@ -499,10 +501,12 @@ static ManagedValue createInputFunctionArgument(
 
 ManagedValue SILGenBuilder::createInputFunctionArgument(
     SILType type, ValueDecl *decl, bool isNoImplicitCopy,
-    LifetimeAnnotation lifetimeAnnotation, bool isClosureCapture) {
+    LifetimeAnnotation lifetimeAnnotation, bool isClosureCapture,
+    bool isFormalParameterPack) {
   return ::createInputFunctionArgument(*this, type, SILLocation(decl), decl,
                                        isNoImplicitCopy, lifetimeAnnotation,
-                                       isClosureCapture);
+                                       isClosureCapture,
+                                       isFormalParameterPack);
 }
 
 ManagedValue

lib/SILGen/SILGenBuilder.h

@@ -230,7 +230,7 @@ class SILGenBuilder : public SILBuilder {
   ManagedValue createInputFunctionArgument(
       SILType type, ValueDecl *decl, bool isNoImplicitCopy = false,
       LifetimeAnnotation lifetimeAnnotation = LifetimeAnnotation::None,
-      bool isClosureCapture = false);
+      bool isClosureCapture = false, bool isFormalParameterPack = false);
 
   /// Create a SILArgument for an input parameter. Uses \p loc to create any
   /// copies necessary. Asserts if used to create a function argument for an out

lib/Serialization/DeserializeSIL.cpp

@@ -971,6 +971,8 @@ SILBasicBlock *SILDeserializer::readSILBasicBlock(SILFunction *Fn,
       fArg->setLifetimeAnnotation(lifetime);
       bool isClosureCapture = (Args[I + 1] >> 19) & 0x1;
       fArg->setClosureCapture(isClosureCapture);
+      bool isFormalParameterPack = (Args[I + 1] >> 20) & 0x1;
+      fArg->setFormalParameterPack(isFormalParameterPack);
       Arg = fArg;
     } else {
       auto OwnershipKind = ValueOwnershipKind((Args[I + 1] >> 8) & 0xF);

lib/Serialization/SerializeSIL.cpp

@@ -647,6 +647,7 @@ void SILSerializer::writeSILBasicBlock(const SILBasicBlock &BB) {
       packedMetadata |= unsigned(SFA->isNoImplicitCopy()) << 16; // 1 bit
       packedMetadata |= unsigned(SFA->getLifetimeAnnotation()) << 17; // 2 bits
       packedMetadata |= unsigned(SFA->isClosureCapture()) << 19;      // 1 bit
+      packedMetadata |= unsigned(SFA->isFormalParameterPack()) << 20; // 1 bit
     }
     // Used: 19 bits. Free: 13.
     //