[SIL] Protect owned arg lifetimes at inlining.

Previously, `begin_borrow [lexical]` were created during SILGen for
@owned arguments.  Such borrows could be deleted if trivially dead,
which was the original reason why @owned arguments were considered
lexical and could not have their destroys hoisted.

Those borrows were however important during inlining because they would
maintain the lifetime of the owned argument.  Unless of course the
borrow scope was trivially dead.  In which case the owned argument's
lifetime would not be maintained.  And if the caller's value was
non-lexical, destroys of the value could be hoisted over deinit
barriers.

Here, during inlining, `move_value [lexical]`s are introduced during
inlining whever the caller's value is non-lexical.  This maintains the
lifetime of the owned argument even after inlining.

Author: nate-chandler

docs/SIL.rst

@@ -2458,6 +2458,12 @@ That the first three have constrained lifetimes is encoded in
 ValueBase::isLexical, which should be checked before changing the lifetime of a
 value.
 
+When a function is inlined into its caller, a lexical borrow scope is added for
+each of its @guaranteed arguments, and a lexical move is added for each of its
+@owned arguments, (unless the values being passed are already lexical
+themselves) ensuring that the lifetimes of the corresponding source-level
+values are not shortened in a way that doesn't respect deinit barriers.
+
 Unlike the other sorts, `alloc_stack [lexical]` isn't a SILValue.  Instead, it
 constrains the lifetime of an addressable variable.  Since the constraint is
 applied to the in-memory representation, no additional lexical SILValue is

lib/SILGen/SILGenProlog.cpp

@@ -303,15 +303,8 @@ struct ArgumentInitHelper {
     // 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) {
-          if (lifetime.isLexical()) {
-            value = SILValue(
-                SGF.B.createBeginBorrow(loc, value, /*isLexical*/ true));
-            SGF.Cleanups.pushCleanup<EndBorrowCleanup>(value);
-          }
-        }
+        // Follow the normal path.  The value's lifetime will be enforced based
+        // on its ownership.
         return value;
       }
 

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -306,6 +306,7 @@ class SILInlineCloner
 
 protected:
   SILValue borrowFunctionArgument(SILValue callArg, unsigned index);
+  SILValue moveFunctionArgument(SILValue callArg, unsigned index);
 
   void visitDebugValueInst(DebugValueInst *Inst);
   void visitHopToExecutorInst(HopToExecutorInst *Inst);
@@ -489,6 +490,10 @@ void SILInlineCloner::cloneInline(ArrayRef<SILValue> AppliedArgs) {
             callArg = newValue;
             borrowedArgs[idx] = true;
           }
+        } else if (paramInfo.isConsumed()) {
+          if (SILValue newValue = moveFunctionArgument(callArg, idx)) {
+            callArg = newValue;
+          }
         }
       }
     }
@@ -652,6 +657,7 @@ Scope scopeForArgument(Scope nonlexicalScope, SILValue callArg, unsigned index,
   if (!enableLexicalLifetimes) {
     // Lexical lifetimes are disabled.  Use the non-lexical scope:
     // - for borrows, do an ownership conversion.
+    // - for moves, do nothing.
     return nonlexicalScope;
   }
   if (!argument->getLifetime().isLexical()) {
@@ -703,6 +709,26 @@ SILValue SILInlineCloner::borrowFunctionArgument(SILValue callArg,
   return beginBuilder.createBeginBorrow(Apply.getLoc(), callArg, isLexical);
 }
 
+SILValue SILInlineCloner::moveFunctionArgument(SILValue callArg,
+                                               unsigned index) {
+  auto scope = scopeForArgument(Scope::None, callArg, index,
+                                Apply.getFunction(), getCalleeFunction());
+  bool isLexical;
+  switch (scope) {
+  case Scope::None:
+    return SILValue();
+  case Scope::Bare:
+    assert(false && "Non-lexical move produced during inlining!?");
+    isLexical = false;
+    break;
+  case Scope::Lexical:
+    isLexical = true;
+    break;
+  }
+  SILBuilderWithScope beginBuilder(Apply.getInstruction(), getBuilder());
+  return beginBuilder.createMoveValue(Apply.getLoc(), callArg, isLexical);
+}
+
 void SILInlineCloner::visitDebugValueInst(DebugValueInst *Inst) {
   // The mandatory inliner drops debug_value instructions when inlining, as if
   // it were a "nodebug" function in C.