[SILInliner] Added lexical lifetimes for arguments.

When the -enable-experimental-lexical-lifetimes flag is passed, added
lexical borrow scopes for every non-trivial argument when inlining a
function.

Author: nate-chandler

lib/SILOptimizer/Utils/SILInliner.cpp

@@ -424,17 +424,40 @@ SILInlineCloner::cloneInline(ArrayRef<SILValue> AppliedArgs) {
   SmallVector<SILValue, 4> entryArgs;
   entryArgs.reserve(AppliedArgs.size());
   SmallBitVector borrowedArgs(AppliedArgs.size());
+  SmallBitVector copiedArgs(AppliedArgs.size());
+  auto enableLexicalLifetimes =
+      Apply.getFunction()
+          ->getModule()
+          .getASTContext()
+          .LangOpts.EnableExperimentalLexicalLifetimes;
 
   auto calleeConv = getCalleeFunction()->getConventions();
   for (auto p : llvm::enumerate(AppliedArgs)) {
     SILValue callArg = p.value();
     unsigned idx = p.index();
-    // Insert begin/end borrow for guaranteed arguments.
-    if (idx >= calleeConv.getSILArgIndexOfFirstParam() &&
-        calleeConv.getParamInfoForSILArg(idx).isGuaranteed()) {
-      if (SILValue newValue = borrowFunctionArgument(callArg, Apply)) {
-        callArg = newValue;
+    if (idx >= calleeConv.getSILArgIndexOfFirstParam()) {
+      if (Apply.getFunction()->hasOwnership() && enableLexicalLifetimes) {
+        if (!callArg->getType().isTrivial(*Apply.getFunction())) {
+          SILBuilderWithScope builder(Apply.getInstruction(), getBuilder());
+          if (calleeConv.getParamInfoForSILArg(idx).isGuaranteed()) {
+            callArg = builder.createBeginBorrow(Apply.getLoc(), callArg,
+                                                /*isLexical*/ true);
+          } else { /*owned*/
+            auto *bbi = builder.createBeginBorrow(Apply.getLoc(), callArg,
+                                                  /*isLexical*/ true);
+            callArg = builder.createCopyValue(Apply.getLoc(), bbi);
+            copiedArgs[idx] = true;
+          }
+        }
         borrowedArgs[idx] = true;
+      } else {
+        // Insert begin/end borrow for guaranteed arguments.
+        if (calleeConv.getParamInfoForSILArg(idx).isGuaranteed()) {
+          if (SILValue newValue = borrowFunctionArgument(callArg, Apply)) {
+            callArg = newValue;
+            borrowedArgs[idx] = true;
+          }
+        }
       }
     }
     entryArgs.push_back(callArg);
@@ -490,7 +513,23 @@ SILInlineCloner::cloneInline(ArrayRef<SILValue> AppliedArgs) {
 
       for (auto *insertPt : endBorrowInsertPts) {
         SILBuilderWithScope returnBuilder(insertPt, getBuilder());
-        returnBuilder.createEndBorrow(Apply.getLoc(), entryArgs[i]);
+        SILValue original;
+        SILValue borrow;
+        if (copiedArgs.test(i)) {
+          auto *cvi =
+              cast<CopyValueInst>(entryArgs[i]->getDefiningInstruction());
+          auto *bbi = cast<BeginBorrowInst>(
+              cvi->getOperand()->getDefiningInstruction());
+          borrow = bbi;
+          original = bbi->getOperand();
+        } else {
+          original = SILValue();
+          borrow = entryArgs[i];
+        }
+        returnBuilder.createEndBorrow(Apply.getLoc(), borrow);
+        if (original) {
+          returnBuilder.createDestroyValue(Apply.getLoc(), original);
+        }
       }
     }
   }