SILGen: Capture address-only lets with the in_guaranteed convention.

Fixes rdar://problem/40828667. If we capture a `let` as inout_aliasable, then definite initialization mistakes capture of the `let` from a defer closure as an inappropriate inout use.

Author: jckarter

lib/IRGen/IRGenDebugInfo.cpp

@@ -1925,8 +1925,12 @@ void IRGenDebugInfoImpl::emitVariableDeclaration(
 
     // There are variables without storage, such as "struct { func foo() {}
     // }". Emit them as constant 0.
-    if (isa<llvm::UndefValue>(Piece))
-      Piece = llvm::ConstantInt::get(IGM.Int64Ty, 0);
+    if (isa<llvm::UndefValue>(Piece)) {
+      auto undefSize = IGM.DataLayout.getTypeSizeInBits(Piece->getType());
+      
+      Piece = llvm::ConstantInt::get(
+         llvm::IntegerType::get(IGM.getLLVMContext(), undefSize), 0);
+    }
 
     if (IsPiece) {
       // Advance the offset and align it for the next piece.

lib/SIL/SILFunctionType.cpp

@@ -881,9 +881,16 @@ lowerCaptureContextParameters(SILModule &M, AnyFunctionRef function,
     case CaptureKind::StorageAddress: {
       // Non-escaping lvalues are captured as the address of the value.
       SILType ty = loweredTy.getAddressType();
+      
+      ParameterConvention convention
+        = ParameterConvention::Indirect_InoutAliasable;
+      
+      if (auto var = dyn_cast<VarDecl>(VD))
+        if (var->isLet())
+          convention = ParameterConvention::Indirect_In_Guaranteed;
+      
       auto param =
-          SILParameterInfo(ty.getASTType(),
-                           ParameterConvention::Indirect_InoutAliasable);
+          SILParameterInfo(ty.getASTType(), convention);
       inputs.push_back(param);
       break;
     }

lib/SILOptimizer/IPO/ClosureSpecializer.cpp

@@ -285,11 +285,17 @@ SingleValueInstruction *CallSiteDescriptor::getClosure() const {
   return CInfo->Closure;
 }
 
-static bool isNonInoutIndirectSILArgument(SILValue Arg,
+static bool isConsumingIndirectSILArgumentConvention(SILArgumentConvention ArgConvention) {
+  return ArgConvention.isIndirectConvention() &&
+    ArgConvention != SILArgumentConvention::Indirect_In_Guaranteed &&
+    ArgConvention != SILArgumentConvention::Indirect_Inout &&
+    ArgConvention != SILArgumentConvention::Indirect_InoutAliasable;
+}
+
+static bool isConsumingIndirectSILArgument(SILValue Arg,
                                           SILArgumentConvention ArgConvention) {
-  return !Arg->getType().isObject() && ArgConvention.isIndirectConvention() &&
-         ArgConvention != SILArgumentConvention::Indirect_Inout &&
-         ArgConvention != SILArgumentConvention::Indirect_InoutAliasable;
+  return !Arg->getType().isObject()
+    && isConsumingIndirectSILArgumentConvention(ArgConvention);
 }
 
 /// Update the callsite to pass in the correct arguments.
@@ -332,12 +338,12 @@ static void rewriteApplyInst(const CallSiteDescriptor &CSDesc,
 
     // Non-inout indirect arguments are not supported yet.
     assert(ArgTy.isObject() ||
-           !isNonInoutIndirectSILArgument(Arg, ArgConvention));
+           !isConsumingIndirectSILArgument(Arg, ArgConvention));
 
     // If argument is not an object and it is an inout parameter,
     // continue...
     if (!ArgTy.isObject() &&
-        !isNonInoutIndirectSILArgument(Arg, ArgConvention)) {
+        !isConsumingIndirectSILArgument(Arg, ArgConvention)) {
       NewArgs.push_back(Arg);
       ++ClosureArgIdx;
       continue;
@@ -472,7 +478,7 @@ void CallSiteDescriptor::extendArgumentLifetime(
   SILBuilderWithScope Builder(getClosure());
 
   // Indirect non-inout arguments are not supported yet.
-  assert(!isNonInoutIndirectSILArgument(Arg, ArgConvention));
+  assert(!isConsumingIndirectSILArgument(Arg, ArgConvention));
 
   if (ArgTy.isObject()) {
     Builder.createRetainValue(getClosure()->getLoc(), Arg,
@@ -534,8 +540,7 @@ static bool isSupportedClosure(const SILInstruction *Closure) {
       }
       auto ArgConvention =
           ClosureCalleeConv.getSILArgumentConvention(ClosureArgIdx);
-      if (ArgConvention != SILArgumentConvention::Indirect_Inout &&
-          ArgConvention != SILArgumentConvention::Indirect_InoutAliasable)
+      if (isConsumingIndirectSILArgumentConvention(ArgConvention))
         return false;
       ++ClosureArgIdx;
     }
@@ -601,7 +606,8 @@ ClosureSpecCloner::initCloned(const CallSiteDescriptor &CallSiteDesc,
       ParamConv = PInfo.getConvention();
       assert(!SILModuleConventions(M).useLoweredAddresses()
              || ParamConv == ParameterConvention::Indirect_Inout
-             || ParamConv == ParameterConvention::Indirect_InoutAliasable);
+             || ParamConv == ParameterConvention::Indirect_InoutAliasable
+             || ParamConv == ParameterConvention::Indirect_In_Guaranteed);
     } else {
       ParamConv = ClosedOverFunConv.getSILType(PInfo).isTrivial(M)
                       ? ParameterConvention::Direct_Unowned

test/SILGen/generic_closures.swift

@@ -144,9 +144,9 @@ class NestedGeneric<U> {
 
 // CHECK: sil hidden @$S16generic_closures018nested_closure_in_A0yxxlF : $@convention(thin) <T> (@in_guaranteed T) -> @out T
 // CHECK:   function_ref [[OUTER_CLOSURE:@\$S16generic_closures018nested_closure_in_A0yxxlFxyXEfU_]]
-// CHECK: sil private [[OUTER_CLOSURE]] : $@convention(thin) <T> (@inout_aliasable T) -> @out T
+// CHECK: sil private [[OUTER_CLOSURE]] : $@convention(thin) <T> (@in_guaranteed T) -> @out T
 // CHECK:   function_ref [[INNER_CLOSURE:@\$S16generic_closures018nested_closure_in_A0yxxlFxyXEfU_xyXEfU_]]
-// CHECK: sil private [[INNER_CLOSURE]] : $@convention(thin) <T> (@inout_aliasable T) -> @out T {
+// CHECK: sil private [[INNER_CLOSURE]] : $@convention(thin) <T> (@in_guaranteed T) -> @out T {
 func nested_closure_in_generic<T>(_ x:T) -> T {
   return { { x }() }()
 }

test/SILOptimizer/definite_init_address_only_let.swift

@@ -0,0 +1,32 @@
+// RUN: %target-swift-frontend -emit-sil -verify %s
+
+func foo<T>(a: Bool, t: T) {
+  let x: T
+  defer { print(x) }
+
+  x = t
+  return
+}
+
+func bar<T>(a: Bool, t: T) {
+  let x: T // expected-note {{defined here}}
+  defer { print(x) } //expected-error{{constant 'x' used before being initialized}}
+
+  if a {
+    x = t
+    return
+  }
+}
+
+func bas<T>(a: Bool, t: T) {
+  let x: T 
+  defer { print(x) }
+
+  if a {
+    x = t
+    return
+  }
+
+  x = t
+}
+