[SILGen] Gave arguments lexical lifetimes.

When the frontend flag -enable-experimental-lexical-lifetimes is passed,
arguments of non-trivial, non-address types get lexical borrow scopes.
The borrow scope begins in the function prolog.  Usages of the arguments
are actually usages of the borrowed value.  The borrow scope is ended
when the function's scope ends.

Author: nate-chandler

lib/SILGen/SILGenProlog.cpp

@@ -251,17 +251,23 @@ struct ArgumentInitHelper {
       // Leave the cleanup on the argument, if any, in place to consume the
       // argument if we're responsible for it.
     }
-    SGF.VarLocs[pd] = SILGenFunction::VarLoc::get(argrv.getValue());
     SILValue value = argrv.getValue();
     SILDebugVariable varinfo(pd->isImmutable(), ArgNo);
     if (!argrv.getType().isAddress()) {
+      if (SGF.getASTContext().LangOpts.EnableExperimentalLexicalLifetimes &&
+          value->getOwnershipKind() != OwnershipKind::None) {
+        value =
+            SILValue(SGF.B.createBeginBorrow(loc, value, /*isLexical*/ true));
+        SGF.Cleanups.pushCleanup<EndBorrowCleanup>(value);
+      }
       SGF.B.createDebugValue(loc, value, varinfo);
     } else {
       if (auto AllocStack = dyn_cast<AllocStackInst>(value))
         AllocStack->setArgNo(ArgNo);
       else
         SGF.B.createDebugValueAddr(loc, value, varinfo);
     }
+    SGF.VarLocs[pd] = SILGenFunction::VarLoc::get(value);
   }
 
   void emitParam(ParamDecl *PD) {

test/SILGen/lexical_lifetime.swift

@@ -15,11 +15,16 @@ struct S {
   let c: C
 }
 
+struct Trivial {
+  let i: Int
+}
+
 enum E {
   case e(C)
 }
 
-func use<T>(_ t: T) {}
+@_silgen_name("use_generic")
+func use_generic<T>(_ t: T) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // Declarations                                                               }}
@@ -54,7 +59,7 @@ func lexical_borrow_let_class() {
 @_silgen_name("lexical_borrow_if_let_class")
 func lexical_borrow_if_let_class() {
   if let c = C(failably: ()) {
-    use(())
+    use_generic(())
   }
 }
 
@@ -79,6 +84,42 @@ func lexical_borrow_let_class_in_enum() {
   let s = E.e(C())
 }
 
+// arguments:
+
+// CHECK-LABEL: sil hidden [ossa] @lexical_borrow_arg_guaranteed_class : $@convention(thin) (@guaranteed C) -> () {
+// CHECK:       {{bb[^,]+}}([[INSTANCE:%[^,]+]] : @guaranteed $C):
+// CHECK:         [[LIFETIME:%[^,]+]] = begin_borrow [lexical] [[INSTANCE]] 
+// CHECK:         debug_value [[LIFETIME]] 
+// CHECK:         [[ADDR:%[^,]+]] = alloc_stack $C
+// CHECK:         store_borrow [[LIFETIME]] to [[ADDR]] 
+// CHECK:         [[USE_GENERIC:%[^,]+]] = function_ref @use_generic
+// CHECK:         [[REGISTER_6:%[^,]+]] = apply [[USE_GENERIC]]<C>([[ADDR]]) 
+// CHECK:         dealloc_stack [[ADDR]] 
+// CHECK:         end_borrow [[LIFETIME]] 
+// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
+// CHECK:         return [[RETVAL]] 
+// CHECK-LABEL: } // end sil function 'lexical_borrow_arg_guaranteed_class'
+@_silgen_name("lexical_borrow_arg_guaranteed_class")
+func lexical_borrow_arg_guaranteed_class(_ c: C) {
+  use_generic(c)
+}
+
+// CHECK-LABEL: sil hidden [ossa] @lexical_borrow_arg_class_addr : $@convention(thin) (@inout C) -> () {
+// CHECK-NOT:     begin_borrow [lexical]
+// CHECK-LABEL: } // end sil function 'lexical_borrow_arg_class_addr'
+@_silgen_name("lexical_borrow_arg_class_addr")
+func lexical_borrow_arg_class_addr(_ c: inout C) {
+  use_generic(c)
+}
+
+// CHECK-LABEL: sil hidden [ossa] @lexical_borrow_arg_trivial : $@convention(thin) (Trivial) -> () {
+// CHECK-NOT:     begin_borrow [lexical]
+// CHECK-LABEL: } // end sil function 'lexical_borrow_arg_trivial'
+@_silgen_name("lexical_borrow_arg_trivial")
+func lexical_borrow_arg_trivial(_ trivial: Trivial) {
+  use_generic(trivial)
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Test                                                                       }}
 ////////////////////////////////////////////////////////////////////////////////