[silgen] Add support for emitting ImmutableBoxes.

Author: gottesmm

include/swift/SIL/TypeLowering.h

@@ -665,6 +665,8 @@ struct SILConstantInfo {
 enum class CaptureKind {
   /// A local value captured as a mutable box.
   Box,
+  /// A local value captured as an immutable box.
+  ImmutableBox,
   /// A local value captured as a single pointer to storage (formed with
   /// @noescape closures).
   StorageAddress,
@@ -674,7 +676,6 @@ enum class CaptureKind {
   Immutable
 };
 
-
 /// TypeConverter - helper class for creating and managing TypeLowerings.
 class TypeConverter {
   friend class TypeLowering;

lib/SIL/IR/SILFunctionType.cpp

@@ -1853,6 +1853,21 @@ lowerCaptureContextParameters(TypeConverter &TC, SILDeclRef function,
       inputs.push_back(param);
       break;
     }
+    case CaptureKind::ImmutableBox: {
+      // The type in the box is lowered in the minimal context.
+      auto minimalLoweredTy =
+          TC.getTypeLowering(AbstractionPattern(genericSig, canType), canType,
+                             TypeExpansionContext::minimal())
+              .getLoweredType();
+      // Lvalues are captured as a box that owns the captured value.
+      auto boxTy =
+          TC.getInterfaceBoxTypeForCapture(VD, minimalLoweredTy.getASTType(),
+                                           /*mutable*/ false);
+      auto convention = ParameterConvention::Direct_Guaranteed;
+      auto param = SILParameterInfo(boxTy, convention);
+      inputs.push_back(param);
+      break;
+    }
     case CaptureKind::StorageAddress: {
       // Non-escaping lvalues are captured as the address of the value.
       SILType ty = loweredTy.getAddressType();

lib/SILGen/SILGenFunction.cpp

@@ -326,7 +326,8 @@ void SILGenFunction::emitCaptures(SILLocation loc,
       Diags.diagnose(capture.getLoc(), diag::value_captured_here);
 
       // Emit an 'undef' of the correct type.
-      switch (SGM.Types.getDeclCaptureKind(capture, expansion)) {
+      auto captureKind = SGM.Types.getDeclCaptureKind(capture, expansion);
+      switch (captureKind) {
       case CaptureKind::Constant:
         capturedArgs.push_back(emitUndef(getLoweredType(type)));
         break;
@@ -338,13 +339,15 @@ void SILGenFunction::emitCaptures(SILLocation loc,
         capturedArgs.push_back(emitUndef(ty));
         break;
       }
+      case CaptureKind::ImmutableBox:
       case CaptureKind::Box: {
+        bool isMutable = captureKind == CaptureKind::Box;
         auto boxTy = SGM.Types.getContextBoxTypeForCapture(
             vd,
             SGM.Types.getLoweredRValueType(TypeExpansionContext::minimal(),
                                            type),
             FunctionDC->getGenericEnvironmentOfContext(),
-            /*mutable*/ true);
+            /*mutable*/ isMutable);
         capturedArgs.push_back(emitUndef(boxTy));
         break;
       }
@@ -497,6 +500,57 @@ void SILGenFunction::emitCaptures(SILLocation loc,
 
       break;
     }
+    case CaptureKind::ImmutableBox: {
+      auto entryValue = getAddressValue(Entry.value);
+      // 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!");
+      // Boxes of opaque return values stay opaque.
+      auto minimalLoweredType = SGM.Types.getLoweredRValueType(
+          TypeExpansionContext::minimal(), type->getCanonicalType());
+      // If this is a boxed variable, we can use it directly.
+      if (Entry.box &&
+          entryValue->getType().getASTType() == minimalLoweredType) {
+        // We can guarantee our own box to the callee.
+        if (canGuarantee) {
+          capturedArgs.push_back(
+              ManagedValue::forUnmanaged(Entry.box).borrow(*this, loc));
+        } else {
+          capturedArgs.push_back(emitManagedRetain(loc, Entry.box));
+        }
+        if (captureCanEscape)
+          escapesToMark.push_back(entryValue);
+      } else {
+        // Address only 'let' values are passed by box.  This isn't great, in
+        // that a variable captured by multiple closures will be boxed for each
+        // one.  This could be improved by doing an "isCaptured" analysis when
+        // emitting address-only let constants, and emit them into an alloc_box
+        // like a variable instead of into an alloc_stack.
+        //
+        // TODO: This might not be profitable anymore with guaranteed captures,
+        // since we could conceivably forward the copied value into the
+        // closure context and pass it down to the partially applied function
+        // in-place.
+        // TODO: Use immutable box for immutable captures.
+        auto boxTy = SGM.Types.getContextBoxTypeForCapture(
+            vd, minimalLoweredType,
+            FunctionDC->getGenericEnvironmentOfContext(),
+            /*mutable*/ false);
+
+        AllocBoxInst *allocBox = B.createAllocBox(loc, boxTy);
+        ProjectBoxInst *boxAddress = B.createProjectBox(loc, allocBox, 0);
+        B.createCopyAddr(loc, entryValue, boxAddress, IsNotTake,
+                         IsInitialization);
+        if (canGuarantee)
+          capturedArgs.push_back(
+              emitManagedRValueWithCleanup(allocBox).borrow(*this, loc));
+        else
+          capturedArgs.push_back(emitManagedRValueWithCleanup(allocBox));
+      }
+
+      break;
+    }
     }
   }
 

lib/SILGen/SILGenProlog.cpp

@@ -517,7 +517,8 @@ static void emitCaptureArguments(SILGenFunction &SGF,
   };
 
   auto expansion = SGF.getTypeExpansionContext();
-  switch (SGF.SGM.Types.getDeclCaptureKind(capture, expansion)) {
+  auto captureKind = SGF.SGM.Types.getDeclCaptureKind(capture, expansion);
+  switch (captureKind) {
   case CaptureKind::Constant: {
     auto type = getVarTypeInCaptureContext();
     auto &lowering = SGF.getTypeLowering(type);
@@ -569,24 +570,31 @@ static void emitCaptureArguments(SILGenFunction &SGF,
     break;
   }
 
+  case CaptureKind::ImmutableBox:
   case CaptureKind::Box: {
     // LValues are captured as a retained @box that owns
     // the captured value.
     auto type = getVarTypeInCaptureContext();
     // Get the content for the box in the minimal  resilience domain because we
     // are declaring a type.
+    bool isMutable = captureKind != CaptureKind::ImmutableBox;
     auto boxTy = SGF.SGM.Types.getContextBoxTypeForCapture(
         VD,
         SGF.SGM.Types.getLoweredRValueType(TypeExpansionContext::minimal(),
                                            type),
-        SGF.F.getGenericEnvironment(), /*mutable*/ true);
+        SGF.F.getGenericEnvironment(), /*mutable*/ isMutable);
     auto *box = SGF.F.begin()->createFunctionArgument(
         SILType::getPrimitiveObjectType(boxTy), VD);
     box->setClosureCapture(true);
     SILValue addr = SGF.B.createProjectBox(VD, box, 0);
-    if (addr->getType().isMoveOnly())
-      addr = SGF.B.createMarkMustCheckInst(
-          VD, addr, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
+    if (addr->getType().isMoveOnly()) {
+      if (isMutable)
+        addr = SGF.B.createMarkMustCheckInst(
+            VD, addr, MarkMustCheckInst::CheckKind::ConsumableAndAssignable);
+      else
+        addr = SGF.B.createMarkMustCheckInst(
+            VD, addr, MarkMustCheckInst::CheckKind::NoConsumeOrAssign);
+    }
     SGF.VarLocs[VD] = SILGenFunction::VarLoc::get(addr, box);
     SILDebugVariable DbgVar(VD->isLet(), ArgNo);
     SGF.B.createDebugValueAddr(Loc, addr, DbgVar);