Steps towards supporting pack expansions properly in signature

lowering and argument emission.

Pack expansions in argument emission don't work yet, but I wanted
to land this bit of incremental progress.

Author: rjmccall

lib/SIL/IR/SILFunctionType.cpp

@@ -28,6 +28,7 @@ add_swift_host_library(swiftSILGen STATIC
   SILGenGlobalVariable.cpp
   SILGenLazyConformance.cpp
   SILGenLValue.cpp
+  SILGenPack.cpp
   SILGenPattern.cpp
   SILGenPoly.cpp
   SILGenProlog.cpp

lib/SILGen/CMakeLists.txt

@@ -234,7 +234,7 @@ class ReleaseValueCleanup : public Cleanup {
 } // end anonymous namespace
 
 namespace {
-/// Cleanup to destroy an initialized variable.
+/// Cleanup to deallocate a now-uninitialized variable.
 class DeallocStackCleanup : public Cleanup {
   SILValue Addr;
 public:

lib/SILGen/SILGenApply.cpp

@@ -1072,6 +1072,15 @@ SILValue SILGenFunction::emitTemporaryAllocation(SILLocation loc, SILType ty,
   return alloc;
 }
 
+SILValue
+SILGenFunction::emitTemporaryPackAllocation(SILLocation loc, SILType ty) {
+  assert(ty.is<SILPackType>());
+  ty = ty.getObjectType();
+  auto *alloc = B.createAllocPack(loc, ty);
+  enterDeallocPackCleanup(alloc);
+  return alloc;
+}
+
 SILValue SILGenFunction::
 getBufferForExprResult(SILLocation loc, SILType ty, SGFContext C) {
   // If you change this, change manageBufferForExprResult below as well.
@@ -3969,7 +3978,8 @@ RValue RValueEmitter::visitKeyPathExpr(KeyPathExpr *E, SGFContext C) {
 
       auto subscript = cast<SubscriptDecl>(decl);
       auto loweredArgs = SGF.emitKeyPathSubscriptOperands(
-          subscript, component.getDeclRef().getSubstitutions(),
+          E, subscript,
+          component.getDeclRef().getSubstitutions(),
           component.getSubscriptArgs());
 
       for (auto &arg : loweredArgs) {

lib/SILGen/SILGenDecl.cpp

@@ -868,7 +868,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// \param subs - Used to get subscript function type and to substitute generic args.
   /// \param argList - The argument list of the subscript.
   SmallVector<ManagedValue, 4>
-  emitKeyPathSubscriptOperands(SubscriptDecl *subscript, SubstitutionMap subs,
+  emitKeyPathSubscriptOperands(SILLocation loc,
+                               SubscriptDecl *subscript,
+                               SubstitutionMap subs,
                                ArgumentList *argList);
 
   /// Convert a block to a native function with a thunk.
@@ -1139,6 +1141,11 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                    bool hasDynamicLifetime = false,
                                    bool isLexical = false);
 
+  /// Emits a temporary allocation for a pack that will be deallocated
+  /// automatically at the end of the current scope.  Returns the address
+  /// of the allocation.
+  SILValue emitTemporaryPackAllocation(SILLocation loc, SILType packTy);
+
   /// Prepares a buffer to receive the result of an expression, either using the
   /// 'emit into' initialization buffer if available, or allocating a temporary
   /// allocation if not.
@@ -1537,7 +1544,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                 SubstitutionMap subs,
                                 bool alreadyConverted);
 
-  PreparedArguments prepareSubscriptIndices(SubscriptDecl *subscript,
+  PreparedArguments prepareSubscriptIndices(SILLocation loc,
+                                            SubscriptDecl *subscript,
                                             SubstitutionMap subs,
                                             AccessStrategy strategy,
                                             ArgumentList *argList);
@@ -2346,10 +2354,24 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
 
   /// Enter a cleanup to deallocate a stack variable.
   CleanupHandle enterDeallocStackCleanup(SILValue address);
+
+  /// Enter a cleanup to deallocate a pack.
+  CleanupHandle enterDeallocPackCleanup(SILValue address);
 
   /// Enter a cleanup to emit a ReleaseValue/DestroyAddr of the specified value.
   CleanupHandle enterDestroyCleanup(SILValue valueOrAddr);
 
+  /// Enter a cleanup to destroy all of the values in the given pack.
+  CleanupHandle enterDestroyPackCleanup(SILValue addr,
+                                        CanPackType formalPackType);
+
+  /// Enter a cleanup to destroy the preceding values in a pack-expansion
+  /// component of a pack.
+  CleanupHandle enterPartialDestroyPackCleanup(SILValue addr,
+                                               CanPackType formalPackType,
+                                               unsigned componentIndex,
+                                               SILValue limitWithinComponent);
+
   /// Return an owned managed value for \p value that is cleaned up using an end_lifetime instruction.
   ///
   /// The end_lifetime cleanup is not placed into the ManagedValue itself and
@@ -2452,6 +2474,65 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   SILDeclRef getAccessorDeclRef(AccessorDecl *accessor) {
     return SGM.getAccessorDeclRef(accessor, F.getResilienceExpansion());
   }
+
+  /// Emit a dynamic loop over a single pack-expansion component of a pack.
+  ///
+  /// \param formalPackType - a pack type with the right shape for the
+  ///   overall pack being iterated over
+  /// \param componentIndex - the index of the pack expansion component
+  ///   within the formal pack type
+  /// \param limitWithinComponent - the number of elements in a prefix of
+  ///   the expansion component to dynamically visit; if null, all elements
+  ///   will be visited
+  /// \param openedElementEnv - a set of opened element archetypes to bind
+  ///   within the loop; can be null to bind no elements
+  /// \param reverse - if true, iterate the elements in reverse order,
+  ///   starting at index limitWithinComponent - 1
+  /// \param emitBody - a function that will be called to emit the body of
+  ///   the loop. It's okay if this has paths that exit the body of the loop,
+  ///   but it should leave the insertion point set at the end. Will be
+  ///   called within a cleanups scope. The first parameter is the current
+  ///   index within the expansion component, a value of type Builtin.Word.
+  ///   The second parameter is that index as a pack indexing instruction
+  ///   that indexes into packs with the shape of the pack expasion.
+  ///   The third parameter is the current pack index within the overall
+  ///   pack, a pack indexing instruction that indexes into packs with the
+  ///   shape of formalPackType.
+  void emitDynamicPackLoop(SILLocation loc,
+                           CanPackType formalPackType,
+                           unsigned componentIndex,
+                           SILValue limitWithinComponent,
+                           GenericEnvironment *openedElementEnv,
+                           bool reverse,
+                        llvm::function_ref<void(SILValue indexWithinComponent,
+                                                SILValue packExpansionIndex,
+                                                SILValue packIndex)> emitBody);
+
+  /// Emit a loop which destroys a prefix of a pack expansion component
+  /// of a pack value.
+  ///
+  /// \param packAddr - the address of the overall pack value
+  /// \param formalPackType - a pack type with the same shape as the
+  ///   overall pack value
+  /// \param componentIndex - the index of the pack expansion component
+  ///   within the formal pack type
+  /// \param limitWithinComponent - the number of elements in a prefix of
+  ///   the expansion component to destroy; if null, all elements in the
+  ///   component will be destroyed
+  void emitPartialDestroyPack(SILLocation loc,
+                              SILValue packAddr,
+                              CanPackType formalPackType,
+                              unsigned componentIndex,
+                              SILValue limitWithinComponent);
+
+  /// Emit a loop which destroys all the elements of a pack value.
+  ///
+  /// \param packAddr - the address of the overall pack value
+  /// \param formalPackType - a pack type with the same shape as the
+  ///   overall pack value
+  void emitDestroyPack(SILLocation loc,
+                       SILValue packAddr,
+                       CanPackType formalPackType);
 };
 
 

lib/SILGen/SILGenExpr.cpp

@@ -3668,7 +3668,7 @@ LValue SILGenLValue::visitSubscriptExpr(SubscriptExpr *e,
     actorIso = getActorIsolation(decl);
 
   auto *argList = e->getArgs();
-  auto indices = SGF.prepareSubscriptIndices(decl, subs, strategy, argList);
+  auto indices = SGF.prepareSubscriptIndices(e, decl, subs, strategy, argList);
 
   CanType formalRValueType = getSubstFormalRValueType(e);
   lv.addMemberSubscriptComponent(SGF, e, decl, subs,