Make BlackHoleInitialization support pack initialization

Fixes rdar://107151145

Author: rjmccall

lib/SILGen/Initialization.h

@@ -491,6 +491,15 @@ class BlackHoleInitialization : public Initialization {
     return buf;
   }
 
+  bool canPerformPackExpansionInitialization() const override {
+    return true;
+  }
+
+  void performPackExpansionInitialization(SILGenFunction &SGF,
+                                          SILLocation loc,
+                                          SILValue indexWithinComponent,
+                llvm::function_ref<void(Initialization *into)> fn) override;
+
   void copyOrInitValueInto(SILGenFunction &SGF, SILLocation loc,
                            ManagedValue value, bool isInit) override;
 

lib/SILGen/SILGenDecl.cpp

@@ -2172,6 +2172,15 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
   llvm_unreachable("unhandled case");
 }
 
+void BlackHoleInitialization::performPackExpansionInitialization(
+                                        SILGenFunction &SGF,
+                                        SILLocation loc,
+                                        SILValue indexWithinComponent,
+                          llvm::function_ref<void(Initialization *into)> fn) {
+  BlackHoleInitialization subInit;
+  fn(&subInit);
+}
+
 void BlackHoleInitialization::copyOrInitValueInto(SILGenFunction &SGF, SILLocation loc,
                                                   ManagedValue value, bool isInit) {
   // Normally we do not do anything if we have a black hole

test/SILGen/variadic-generic-tuples.swift

@@ -283,3 +283,11 @@ struct MemberwiseTupleHolder<each T> {
 func callVariadicMemberwiseInit() -> MemberwiseTupleHolder<Int, String> {
   return MemberwiseTupleHolder(content: (0, "hello"))
 }
+
+// rdar://107151145: when we tuple-destructure a black hole
+// initialization, the resulting element initializations need to
+// handle pack expansion initialization
+struct EmptyContainer<each T> {}
+func f<each T>(_: repeat each T) {
+  let _ = (repeat EmptyContainer<each T>())
+}