Implement the caller side of return types containing variadic packs

This is all relatively nicely abstracted, which is not to say that
it didn't take an awful lot of plumbing to get it to work.  The basic
problem here is inherent: we need to do component-specific setup and
teardown, and unfortunately in the current representation we have to
do that with separate loops and without any dominance relationships.
(This is the same thing preventing us from doing borrows in the
general case.)  The result is that the general case of result emission
is to emit every element of the expansion into a temporary tuple
(requiring a pack loop before the call to initialize the pack), then
process those elements in the body of a second pack loop after the
call.  And that's terrible enough that we really have to do the work
to try to avoid it, which makes all the APIs more complicated.

Anyway, most of the way through the basic plumbing for variadic
generics now.  Next is reabstraction, I think, which I hope will
mostly mean fixing bugs in the infrastructure I've already written.

Author: rjmccall

lib/SILGen/Initialization.h

@@ -122,6 +122,31 @@ class Initialization {
     llvm_unreachable("Must implement if canPerformPackExpansionInitialization"
                      "returns true");
   }
+
+  /// Given that this supports pack expansion initialization, can it
+  /// perform *in place* pack expansion initialization by producing
+  /// a pack element of the given type?
+  ///
+  /// The dominance relationship gets a little screwed up here; only
+  /// return true if it's okay for the address to be written into a
+  /// pack and then initialized later.
+  virtual bool
+  canPerformInPlacePackInitialization(GenericEnvironment *env,
+                                      SILType eltAddrTy) const {
+    return false;
+  }
+
+  /// Given that this supports in-place pack expansion initialization,
+  /// return the address of the storage.
+  ///
+  /// For convenience, the same element type that was accepted before
+  /// is passed again.
+  virtual SILValue getAddressForInPlacePackInitialization(SILGenFunction &SGF,
+                                                          SILLocation loc,
+                                                          SILType eltAddrTy) {
+    llvm_unreachable("Must implement if canPerformInPlacePackInitialization"
+                     "returns true");
+  }
 
   /// Return true if we can get the addresses of elements with the
   /// 'splitIntoTupleElements' method.  Subclasses can override this to
@@ -365,6 +390,13 @@ class InPlacePackExpansionInitialization : public Initialization {
                                           SILValue indexWithinComponent,
                   llvm::function_ref<void(Initialization *into)> fn) override;
 
+  bool canPerformInPlacePackInitialization(GenericEnvironment *env,
+                                           SILType eltAddrTy) const override;
+
+  SILValue getAddressForInPlacePackInitialization(SILGenFunction &SGF,
+                                                  SILLocation loc,
+                                                  SILType eltAddrTy) override;
+
   virtual CanPackExpansionType getLoweredExpansionType() const = 0;
   virtual CleanupHandle enterPartialDestroyCleanup(SILGenFunction &SGF,
                                      SILValue indexWithinComponent) = 0;