[SILGen] Only lexical types get lexical lifetimes.

Only emit `begin_borrow [lexical]` and only mark `alloc_stack`s
`[lexical]` when the variable in question's lifetime is lexical, not
eager move.

Author: nate-chandler

include/swift/SIL/SILFunction.h

@@ -1346,6 +1346,13 @@ class SILFunction
   // Miscellaneous
   //===--------------------------------------------------------------------===//
 
+  /// A value's lifetime, determined by looking at annotations on its decl and
+  /// the default lifetime for the type.
+  Lifetime getLifetime(VarDecl *decl, SILType ty) {
+    return ty.getLifetime(*this).getLifetimeForAnnotatedValue(
+        decl->getLifetimeAnnotation());
+  }
+
   /// verify - Run the IR verifier to make sure that the SILFunction follows
   /// invariants.
   void verify(bool SingleFunction = true) const;

lib/SILGen/ResultPlan.cpp

@@ -68,9 +68,10 @@ class IndirectOpenedSelfCleanup final : public Cleanup {
     assert(box && "buffer never emitted before activating cleanup?!");
     auto theBox = box;
     if (SGF.getASTContext().SILOpts.supportsLexicalLifetimes(SGF.getModule())) {
-      auto *bbi = cast<BeginBorrowInst>(theBox);
-      SGF.B.createEndBorrow(loc, bbi);
-      theBox = bbi->getOperand();
+      if (auto *bbi = cast<BeginBorrowInst>(theBox)) {
+        SGF.B.createEndBorrow(loc, bbi);
+        theBox = bbi->getOperand();
+      }
     }
     SGF.B.createDeallocBox(loc, theBox);
   }

lib/SILGen/SILGenApply.cpp

@@ -3656,9 +3656,10 @@ class DeallocateUninitializedBox : public Cleanup {
   void emit(SILGenFunction &SGF, CleanupLocation l, ForUnwind_t forUnwind) override {
     auto theBox = box;
     if (SGF.getASTContext().SILOpts.supportsLexicalLifetimes(SGF.getModule())) {
-      auto *bbi = cast<BeginBorrowInst>(theBox);
-      SGF.B.createEndBorrow(l, bbi);
-      theBox = bbi->getOperand();
+      if (auto *bbi = cast<BeginBorrowInst>(theBox)) {
+        SGF.B.createEndBorrow(l, bbi);
+        theBox = bbi->getOperand();
+      }
     }
     SGF.B.createDeallocBox(l, theBox);
   }

lib/SILGen/SILGenBuilder.cpp

@@ -433,16 +433,17 @@ ManagedValue SILGenBuilder::createLoadCopy(SILLocation loc, ManagedValue v,
   return SGF.emitManagedRValueWithCleanup(result, lowering);
 }
 
-static ManagedValue createInputFunctionArgument(SILGenBuilder &B, SILType type,
-                                                SILLocation loc,
-                                                ValueDecl *decl = nullptr,
-                                                bool isNoImplicitCopy = false) {
+static ManagedValue createInputFunctionArgument(
+    SILGenBuilder &B, SILType type, SILLocation loc, ValueDecl *decl = nullptr,
+    bool isNoImplicitCopy = false,
+    LifetimeAnnotation lifetimeAnnotation = LifetimeAnnotation::None) {
   auto &SGF = B.getSILGenFunction();
   SILFunction &F = B.getFunction();
   assert((F.isBare() || decl) &&
          "Function arguments of non-bare functions must have a decl");
   auto *arg = F.begin()->createFunctionArgument(type, decl);
   arg->setNoImplicitCopy(isNoImplicitCopy);
+  arg->setLifetimeAnnotation(lifetimeAnnotation);
   switch (arg->getArgumentConvention()) {
   case SILArgumentConvention::Indirect_In_Guaranteed:
   case SILArgumentConvention::Direct_Guaranteed:
@@ -476,11 +477,11 @@ static ManagedValue createInputFunctionArgument(SILGenBuilder &B, SILType type,
   llvm_unreachable("bad parameter convention");
 }
 
-ManagedValue SILGenBuilder::createInputFunctionArgument(SILType type,
-                                                        ValueDecl *decl,
-                                                        bool isNoImplicitCopy) {
+ManagedValue SILGenBuilder::createInputFunctionArgument(
+    SILType type, ValueDecl *decl, bool isNoImplicitCopy,
+    LifetimeAnnotation lifetimeAnnotation) {
   return ::createInputFunctionArgument(*this, type, SILLocation(decl), decl,
-                                       isNoImplicitCopy);
+                                       isNoImplicitCopy, lifetimeAnnotation);
 }
 
 ManagedValue

lib/SILGen/SILGenBuilder.h

@@ -226,8 +226,9 @@ class SILGenBuilder : public SILBuilder {
 
   /// Create a SILArgument for an input parameter. Asserts if used to create a
   /// function argument for an out parameter.
-  ManagedValue createInputFunctionArgument(SILType type, ValueDecl *decl,
-                                           bool isNoImplicitCopy = false);
+  ManagedValue createInputFunctionArgument(
+      SILType type, ValueDecl *decl, bool isNoImplicitCopy = false,
+      LifetimeAnnotation lifetimeAnnotation = LifetimeAnnotation::None);
 
   /// Create a SILArgument for an input parameter. Uses \p loc to create any
   /// copies necessary. Asserts if used to create a function argument for an out

lib/SILGen/SILGenDecl.cpp

@@ -299,9 +299,10 @@ class DeallocateUninitializedLocalVariable : public Cleanup {
             ForUnwind_t forUnwind) override {
     auto box = Box;
     if (SGF.getASTContext().SILOpts.supportsLexicalLifetimes(SGF.getModule())) {
-      auto *bbi = cast<BeginBorrowInst>(box);
-      SGF.B.createEndBorrow(l, bbi);
-      box = bbi->getOperand();
+      if (auto *bbi = dyn_cast<BeginBorrowInst>(box)) {
+        SGF.B.createEndBorrow(l, bbi);
+        box = bbi->getOperand();
+      }
     }
     SGF.B.createDeallocBox(l, box);
   }
@@ -367,7 +368,11 @@ class LocalVariableInitialization : public SingleBufferInitialization {
       Box = SGF.B.createMarkUninitialized(decl, Box, kind.getValue());
 
     if (SGF.getASTContext().SILOpts.supportsLexicalLifetimes(SGF.getModule())) {
-      Box = SGF.B.createBeginBorrow(decl, Box, /*isLexical=*/true);
+      auto loweredType = SGF.getTypeLowering(decl->getType()).getLoweredType();
+      auto lifetime = SGF.F.getLifetime(decl, loweredType);
+      if (lifetime.isLexical()) {
+        Box = SGF.B.createBeginBorrow(decl, Box, /*isLexical=*/true);
+      }
     }
 
     Addr = SGF.B.createProjectBox(decl, Box, 0);
@@ -489,11 +494,13 @@ class LetValueInitialization : public Initialization {
     }
 
     if (needsTemporaryBuffer) {
-      bool isLexical =
+      bool lexicalLifetimesEnabled =
           SGF.getASTContext().SILOpts.supportsLexicalLifetimes(SGF.getModule());
+      auto lifetime = SGF.F.getLifetime(vd, lowering->getLoweredType());
+      auto isLexical = lexicalLifetimesEnabled && lifetime.isLexical();
       address =
           SGF.emitTemporaryAllocation(vd, lowering->getLoweredType(),
-                                      false /*hasDynamicLifetime*/, isLexical);
+                                      /*hasDynamicLifetime=*/false, isLexical);
       if (isUninitialized)
         address = SGF.B.createMarkUninitializedVar(vd, address);
       DestroyCleanup = SGF.enterDormantTemporaryCleanup(address, *lowering);
@@ -575,9 +582,14 @@ class LetValueInitialization : public Initialization {
           PrologueLoc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
     }
 
-    // Then if we don't have move only, just perform a lexical borrow.
-    if (!SGF.getASTContext().LangOpts.Features.count(Feature::MoveOnly))
-      return SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true);
+    // Then if we don't have move only, just perform a lexical borrow if the
+    // lifetime is lexical.
+    if (!SGF.getASTContext().LangOpts.Features.count(Feature::MoveOnly)) {
+      if (SGF.F.getLifetime(vd, value->getType()).isLexical())
+        return SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true);
+      else
+        return value;
+    }
 
     // Otherwise, we need to perform some additional processing. First, if we
     // have an owned moveonly value that had a cleanup, then create a move_value
@@ -612,10 +624,14 @@ class LetValueInitialization : public Initialization {
           PrologueLoc, value, MarkMustCheckInst::CheckKind::NoImplicitCopy);
     }
 
-    // Otherwise, if we do not have a no implicit copy variable, just do a
-    // borrow lexical. This is the "normal path".
-    if (!vd->getAttrs().hasAttribute<NoImplicitCopyAttr>())
-      return SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true);
+    // Otherwise, if we do not have a no implicit copy variable, just follow
+    // the "normal path": perform a lexical borrow if the lifetime is lexical.
+    if (!vd->getAttrs().hasAttribute<NoImplicitCopyAttr>()) {
+      if (SGF.F.getLifetime(vd, value->getType()).isLexical())
+        return SGF.B.createBeginBorrow(PrologueLoc, value, /*isLexical*/ true);
+      else
+        return value;
+    }
 
     // If we have a no implicit copy lexical, emit the instruction stream so
     // that the move checker knows to check this variable.
@@ -1830,10 +1846,13 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
       return;
     }
 
-    auto *bbi = cast<BeginBorrowInst>(loc.box);
-    B.createEndBorrow(silLoc, bbi);
-    B.emitDestroyValueOperation(silLoc, bbi->getOperand());
+    if (auto *bbi = dyn_cast<BeginBorrowInst>(loc.box)) {
+      B.createEndBorrow(silLoc, bbi);
+      B.emitDestroyValueOperation(silLoc, bbi->getOperand());
+      return;
+    }
 
+    B.emitDestroyValueOperation(silLoc, loc.box);
     return;
   }
 
@@ -1855,6 +1874,11 @@ void SILGenFunction::destroyLocalVariable(SILLocation silLoc, VarDecl *vd) {
     return;
   }
 
+  if (!F.getLifetime(vd, Val->getType()).isLexical()) {
+    B.emitDestroyValueOperation(silLoc, Val);
+    return;
+  }
+
   // This handles any case where we copy + begin_borrow or copyable_to_moveonly
   // + begin_borrow. In either case we just need to end the lifetime of the
   // begin_borrow's operand.

lib/SILGen/SILGenProlog.cpp

@@ -58,12 +58,15 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
   CanSILFunctionType fnTy;
   ArrayRef<SILParameterInfo> &parameters;
   bool isNoImplicitCopy;
+  LifetimeAnnotation lifetimeAnnotation;
 
   EmitBBArguments(SILGenFunction &sgf, SILBasicBlock *parent, SILLocation l,
                   CanSILFunctionType fnTy,
-                  ArrayRef<SILParameterInfo> &parameters, bool isNoImplicitCopy)
+                  ArrayRef<SILParameterInfo> &parameters, bool isNoImplicitCopy,
+                  LifetimeAnnotation lifetimeAnnotation)
       : SGF(sgf), parent(parent), loc(l), fnTy(fnTy), parameters(parameters),
-        isNoImplicitCopy(isNoImplicitCopy) {}
+        isNoImplicitCopy(isNoImplicitCopy),
+        lifetimeAnnotation(lifetimeAnnotation) {}
 
   ManagedValue visitType(CanType t, AbstractionPattern orig) {
     return visitType(t, orig, /*isInOut=*/false);
@@ -90,7 +93,8 @@ class EmitBBArguments : public CanTypeVisitor<EmitBBArguments,
     auto paramType =
         SGF.F.mapTypeIntoContext(SGF.getSILType(parameterInfo, fnTy));
     ManagedValue mv = SGF.B.createInputFunctionArgument(
-        paramType, loc.getAsASTNode<ValueDecl>(), isNoImplicitCopy);
+        paramType, loc.getAsASTNode<ValueDecl>(), isNoImplicitCopy,
+        lifetimeAnnotation);
 
     // This is a hack to deal with the fact that Self.Type comes in as a static
     // metatype, but we have to downcast it to a dynamic Self metatype to get
@@ -239,13 +243,14 @@ struct ArgumentInitHelper {
   unsigned getNumArgs() const { return ArgNo; }
 
   ManagedValue makeArgument(Type ty, bool isInOut, bool isNoImplicitCopy,
-                            SILBasicBlock *parent, SILLocation l) {
+                            LifetimeAnnotation lifetime, SILBasicBlock *parent,
+                            SILLocation l) {
     assert(ty && "no type?!");
 
     // Create an RValue by emitting destructured arguments into a basic block.
     CanType canTy = ty->getCanonicalType();
     EmitBBArguments argEmitter(SGF, parent, l, f.getLoweredFunctionType(),
-                               parameters, isNoImplicitCopy);
+                               parameters, isNoImplicitCopy, lifetime);
 
     // Note: inouts of tuples are not exploded, so we bypass visit().
     AbstractionPattern origTy = OrigFnType
@@ -266,17 +271,24 @@ struct ArgumentInitHelper {
 
     // Look for the following annotations on the function argument:
     // - @noImplicitCopy
+    // - @_eagerMove
+    // - @_lexical
     auto isNoImplicitCopy = pd->isNoImplicitCopy();
+    auto lifetime = SGF.F.getLifetime(pd, value->getType());
 
     // If we have a no implicit copy argument and the argument is trivial,
     // we need to use copyable to move only to convert it to its move only
     // form.
     if (!isNoImplicitCopy) {
       if (!value->getType().isMoveOnly()) {
+        // Follow the "normal path": perform a lexical borrow if the lifetime is
+        // lexical.
         if (value->getOwnershipKind() == OwnershipKind::Owned) {
-          value =
-              SILValue(SGF.B.createBeginBorrow(loc, value, /*isLexical*/ true));
-          SGF.Cleanups.pushCleanup<EndBorrowCleanup>(value);
+          if (lifetime.isLexical()) {
+            value = SILValue(
+                SGF.B.createBeginBorrow(loc, value, /*isLexical*/ true));
+            SGF.Cleanups.pushCleanup<EndBorrowCleanup>(value);
+          }
         }
         return value;
       }
@@ -343,8 +355,8 @@ struct ArgumentInitHelper {
     SILLocation loc(pd);
     loc.markAsPrologue();
 
-    ManagedValue argrv =
-        makeArgument(ty, pd->isInOut(), pd->isNoImplicitCopy(), parent, loc);
+    ManagedValue argrv = makeArgument(ty, pd->isInOut(), pd->isNoImplicitCopy(),
+                                      pd->getLifetimeAnnotation(), parent, loc);
 
     if (pd->isInOut()) {
       assert(argrv.getType().isAddress() && "expected inout to be address");
@@ -362,7 +374,10 @@ struct ArgumentInitHelper {
     } else {
       if (auto *allocStack = dyn_cast<AllocStackInst>(value)) {
         allocStack->setArgNo(ArgNo);
-        allocStack->setIsLexical();
+        if (SGF.getASTContext().SILOpts.supportsLexicalLifetimes(
+                SGF.getModule()) &&
+            SGF.F.getLifetime(pd, value->getType()).isLexical())
+          allocStack->setIsLexical();
       } else {
         SGF.B.createDebugValueAddr(loc, value, varinfo);
       }
@@ -397,8 +412,9 @@ struct ArgumentInitHelper {
     Scope discardScope(SGF.Cleanups, CleanupLocation(PD));
 
     // Manage the parameter.
-    auto argrv = makeArgument(type, PD->isInOut(), PD->isNoImplicitCopy(),
-                              &*f.begin(), paramLoc);
+    auto argrv =
+        makeArgument(type, PD->isInOut(), PD->isNoImplicitCopy(),
+                     PD->getLifetimeAnnotation(), &*f.begin(), paramLoc);
 
     // Emit debug information for the argument.
     SILLocation loc(PD);

lib/SILGen/Scope.cpp

@@ -60,7 +60,10 @@ static void lifetimeExtendAddressOnlyRValueSubValues(
     // TODO: Should these boxes that extend lifetimes for rvalue subobjects ever
     //       be lexical?
     if (SGF.getASTContext().SILOpts.supportsLexicalLifetimes(SGF.getModule())) {
-      box = SGF.B.createBeginBorrow(loc, box, /*isLexical=*/true);
+      if (v->getType().getLifetime(SGF.F).isLexical()) {
+        box = SGF.B.createBeginBorrow(loc, box,
+                                      /*isLexical=*/true);
+      }
     }
     SILValue addr = SGF.B.createProjectBox(loc, box, 0);
     SGF.B.createCopyAddr(loc, v, addr, IsTake, IsInitialization);