[move-only] Update SILGen/MoveCheckers so that vars are emitted in eagerly projected box form.

This is the first slice of bringing up escaping closure support. The support is
based around introducing a new type of SILGen VarLoc: a VarLoc with a box and
without a value. Because the VarLoc only has a box, we have to in SILGen always
eagerly reproject out the address from the box. The reason why I am doing this
is that it makes it easy for the move checker to distinguish in between
different accesses to the box that we want to check separately. As such every
time that we open the box, we insert a mark_must_check
[assignable_but_not_consumable] on that project. If allocbox_to_stack manages to
determine that the box can be stack allocated, we eliminate all of the
mark_must_check and place a new mark_must_check [consumable_and_assignable] on
the alloc_stack.  The end result is that we get the old model that we had before
and also can support escaping closures.

Author: gottesmm

lib/SILGen/SILGenConstructor.cpp

@@ -399,7 +399,11 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
   // Allocate the local variable for 'self'.
   emitLocalVariableWithCleanup(selfDecl, MUIKind)->finishInitialization(*this);
 
-  SILValue selfLV = VarLocs[selfDecl].value;
+  ManagedValue selfLV =
+      maybeEmitValueOfLocalVarDecl(selfDecl, AccessKind::ReadWrite);
+  if (!selfLV)
+    selfLV = maybeEmitAddressForBoxOfLocalVarDecl(selfDecl, selfDecl);
+  assert(selfLV);
 
   // Emit the prolog.
   emitBasicProlog(ctor->getParameters(),
@@ -491,7 +495,13 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
 
     if (!F.getConventions().hasIndirectSILResults()) {
       // Otherwise, load and return the final 'self' value.
-      selfValue = lowering.emitLoad(B, cleanupLoc, selfLV,
+      if (selfLV.getType().isMoveOnly()) {
+        selfLV = B.createMarkMustCheckInst(
+            cleanupLoc, selfLV,
+            MarkMustCheckInst::CheckKind::AssignableButNotConsumable);
+      }
+
+      selfValue = lowering.emitLoad(B, cleanupLoc, selfLV.getValue(),
                                     LoadOwnershipQualifier::Copy);
 
       // Inject the self value into an optional if the constructor is failable.
@@ -513,17 +523,16 @@ void SILGenFunction::emitValueConstructor(ConstructorDecl *ctor) {
         returnAddress = completeReturnAddress;
       } else {
         // If this is a failable initializer, project out the payload.
-        returnAddress = B.createInitEnumDataAddr(cleanupLoc,
-                                                 completeReturnAddress,
-                                         getASTContext().getOptionalSomeDecl(),
-                                                 selfLV->getType());
+        returnAddress = B.createInitEnumDataAddr(
+            cleanupLoc, completeReturnAddress,
+            getASTContext().getOptionalSomeDecl(), selfLV.getType());
       }
 
       // We have to do a non-take copy because someone else may be using the
       // box (e.g. someone could have closed over it).
-      B.createCopyAddr(cleanupLoc, selfLV, returnAddress,
+      B.createCopyAddr(cleanupLoc, selfLV.getLValueAddress(), returnAddress,
                        IsNotTake, IsInitialization);
-      
+
       // Inject the enum tag if the result is optional because of failability.
       if (ctor->isFailable()) {
         // Inject the 'Some' tag.
@@ -1022,14 +1031,19 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
 static ManagedValue emitSelfForMemberInit(SILGenFunction &SGF, SILLocation loc,
                                           VarDecl *selfDecl) {
   CanType selfFormalType = selfDecl->getType()->getCanonicalType();
-  if (selfFormalType->hasReferenceSemantics())
+  if (selfFormalType->hasReferenceSemantics()) {
     return SGF.emitRValueForDecl(loc, selfDecl, selfFormalType,
                                  AccessSemantics::DirectToStorage,
                                  SGFContext::AllowImmediatePlusZero)
       .getAsSingleValue(SGF, loc);
-  else
+  } else {
+    // First see if we have a variable that is boxed without a value.
+    if (auto value = SGF.maybeEmitAddressForBoxOfLocalVarDecl(loc, selfDecl))
+      return value;
+    // Otherwise, emit the address directly.
     return SGF.emitAddressOfLocalVarDecl(loc, selfDecl, selfFormalType,
                                          SGFAccessKind::Write);
+  }
 }
 
 // FIXME: Can emitMemberInit() share code with InitializationForPattern in

lib/SILGen/SILGenDecl.cpp

@@ -376,12 +376,8 @@ class LocalVariableInitialization : public SingleBufferInitialization {
       }
     }
 
-    Addr = SGF.B.createProjectBox(decl, Box, 0);
-    if (Addr->getType().isMoveOnly()) {
-      // TODO: Handle no implicit copy here.
-      Addr = SGF.B.createMarkMustCheckInst(
-          decl, Addr, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
-    }
+    if (!Box->getType().isBoxedNonCopyableType(Box->getFunction()))
+      Addr = SGF.B.createProjectBox(decl, Box, 0);
 
     // Push a cleanup to destroy the local variable.  This has to be
     // inactive until the variable is initialized.
@@ -401,16 +397,24 @@ class LocalVariableInitialization : public SingleBufferInitialization {
   }
 
   SILValue getAddress() const {
+    assert(Addr);
     return Addr;
   }
 
+  /// If we have an address, returns the address. Otherwise, if we only have a
+  /// box, lazily projects it out and returns it.
   SILValue getAddressForInPlaceInitialization(SILGenFunction &SGF,
                                               SILLocation loc) override {
+    if (!Addr && Box) {
+      auto pbi = SGF.B.createProjectBox(loc, Box, 0);
+      return pbi;
+    }
+
     return getAddress();
   }
 
   bool isInPlaceInitializationOfGlobal() const override {
-    return isa<GlobalAddrInst>(getAddress());
+    return dyn_cast_or_null<GlobalAddrInst>(Addr);
   }
 
   void finishUninitialized(SILGenFunction &SGF) override {
@@ -421,7 +425,11 @@ class LocalVariableInitialization : public SingleBufferInitialization {
     /// Remember that this is the memory location that we've emitted the
     /// decl to.
     assert(SGF.VarLocs.count(decl) == 0 && "Already emitted the local?");
-    SGF.VarLocs[decl] = SILGenFunction::VarLoc::get(Addr, Box);
+
+    if (Addr)
+      SGF.VarLocs[decl] = SILGenFunction::VarLoc::get(Addr, Box);
+    else
+      SGF.VarLocs[decl] = SILGenFunction::VarLoc::getForBox(Box);
 
     SingleBufferInitialization::finishInitialization(SGF);
     assert(!DidFinish &&

lib/SILGen/SILGenFunction.cpp

@@ -357,7 +357,8 @@ void SILGenFunction::emitCaptures(SILLocation loc,
 
     // Get an address value for a SILValue if it is address only in an type
     // expansion context without opaque archetype substitution.
-    auto getAddressValue = [&](SILValue entryValue) -> SILValue {
+    auto getAddressValue = [&](VarLoc entryVarLoc) -> SILValue {
+      SILValue entryValue = entryVarLoc.getValueOrBoxedValue(*this, vd);
       if (SGM.M.useLoweredAddresses()
           && SGM.Types
                  .getTypeLowering(
@@ -425,14 +426,14 @@ void SILGenFunction::emitCaptures(SILLocation loc,
       if (canGuarantee) {
         // No-escaping stored declarations are captured as the
         // address of the value.
-        auto entryValue = getAddressValue(Entry.value);
+        auto entryValue = getAddressValue(Entry);
         capturedArgs.push_back(ManagedValue::forBorrowedRValue(entryValue));
       }
       else if (!silConv.useLoweredAddresses()) {
         capturedArgs.push_back(
           B.createCopyValue(loc, ManagedValue::forUnmanaged(Entry.value)));
       } else {
-        auto entryValue = getAddressValue(Entry.value);
+        auto entryValue = getAddressValue(Entry);
         // We cannot pass a valid SILDebugVariable while creating the temp here
         // See rdar://60425582
         auto addr = B.createAllocStack(loc, entryValue->getType().getObjectType());
@@ -443,7 +444,7 @@ void SILGenFunction::emitCaptures(SILLocation loc,
       break;
     }
     case CaptureKind::StorageAddress: {
-      auto entryValue = getAddressValue(Entry.value);
+      auto entryValue = getAddressValue(Entry);
       // No-escaping stored declarations are captured as the
       // address of the value.
       assert(entryValue->getType().isAddress() && "no address for captured var!");
@@ -452,7 +453,7 @@ void SILGenFunction::emitCaptures(SILLocation loc,
     }
 
     case CaptureKind::Box: {
-      auto entryValue = getAddressValue(Entry.value);
+      auto entryValue = getAddressValue(Entry);
       // LValues are captured as both the box owning the value and the
       // address of the value.
       assert(entryValue->getType().isAddress() && "no address for captured var!");
@@ -501,7 +502,7 @@ void SILGenFunction::emitCaptures(SILLocation loc,
       break;
     }
     case CaptureKind::ImmutableBox: {
-      auto entryValue = getAddressValue(Entry.value);
+      auto entryValue = getAddressValue(Entry);
       // LValues are captured as both the box owning the value and the
       // address of the value.
       assert(entryValue->getType().isAddress() &&

lib/SILGen/SILGenFunction.h

@@ -25,6 +25,7 @@
 #include "swift/Basic/ProfileCounter.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/SIL/SILBuilder.h"
+#include "swift/SIL/SILType.h"
 #include "llvm/ADT/PointerIntPair.h"
 
 namespace swift {
@@ -394,11 +395,12 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   FormalEvaluationContext FormalEvalContext;
 
   /// VarLoc - representation of an emitted local variable or constant.  There
-  /// are three scenarios here:
+  /// are four scenarios here:
   ///
-  ///  1) This could be a simple "var" or "let" emitted into an alloc_box.  In
-  ///     this case, 'value' contains a pointer (it is always an address) to the
-  ///     value, and 'box' contains a pointer to the retain count for the box.
+  ///  1) This could be a simple copyable "var" or "let" emitted into an
+  ///     alloc_box.  In this case, 'value' contains a pointer (it is always an
+  ///     address) to the value, and 'box' contains a pointer to the retain
+  ///     count for the box.
   ///  2) This could be a simple non-address-only "let" represented directly. In
   ///     this case, 'value' is the value of the let and is never of address
   ///     type.  'box' is always nil.
@@ -407,13 +409,20 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   ///     incoming argument of 'in_guaranteed' convention).  In this case,
   ///     'value' is a pointer to the memory (and thus, its type is always an
   ///     address) and the 'box' is nil.
+  ///  4) This could be a noncopyable "var" or "let" emitted into an
+  ///     alloc_box. In this case, 'value' is nil and the 'box' contains the box
+  ///     itself. The user must always reproject from the box and insert an
+  ///     access marker/must_must_check as appropriate.
   ///
-  /// Generally, code shouldn't be written to enumerate these three cases, it
+  /// Generally, code shouldn't be written to enumerate these four cases, it
   /// should just handle the case of "box or not" or "address or not", depending
   /// on what the code cares about.
   struct VarLoc {
     /// value - the value of the variable, or the address the variable is
     /// stored at (if "value.getType().isAddress()" is true).
+    ///
+    /// It may be invalid if we are supposed to lazily project out an address
+    /// from a box.
     SILValue value;
 
     /// box - This is the retainable box for something emitted to an alloc_box.
@@ -427,6 +436,25 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
       Result.box = box;
       return Result;
     }
+
+    static VarLoc getForBox(SILValue box) {
+      VarLoc Result;
+      Result.value = SILValue();
+      Result.box = box;
+      return Result;
+    }
+
+    /// Return either the value if we have one or if we only have a box, project
+    /// our a new box address and return that.
+    SILValue getValueOrBoxedValue(SILGenFunction &SGF,
+                                  SILLocation loc = SILLocation::invalid()) {
+      if (value)
+        return value;
+      assert(box);
+      if (loc.isNull())
+        loc = SGF.CurrentSILLoc;
+      return SGF.B.createProjectBox(loc, box, 0);
+    }
   };
 
   /// VarLocs - Entries in this map are generated when a PatternBindingDecl is
@@ -1467,6 +1495,9 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   ManagedValue maybeEmitValueOfLocalVarDecl(
       VarDecl *var, AccessKind accessKind);
 
+  ManagedValue maybeEmitAddressForBoxOfLocalVarDecl(SILLocation loc,
+                                                    VarDecl *var);
+
   /// Produce an RValue for a reference to the specified declaration,
   /// with the given type and in response to the specified expression.  Try to
   /// emit into the specified SGFContext to avoid copies (when provided).