SILGen: Fix up ownership of key path entry points for +0.

Author: jckarter

lib/SIL/SILVerifier.cpp

@@ -3849,7 +3849,13 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
         case KeyPathPatternComponent::Kind::SettableProperty: {
           bool hasIndices = !component.getSubscriptIndices().empty();
 
-          // Getter should be <Sig...> @convention(thin) (@in Base) -> @out Result
+          ParameterConvention normalArgConvention;
+          if (F.getModule().getOptions().EnableGuaranteedNormalArguments)
+            normalArgConvention = ParameterConvention::Indirect_In_Guaranteed;
+          else
+            normalArgConvention = ParameterConvention::Indirect_In;
+        
+          // Getter should be <Sig...> @convention(thin) (@in_guaranteed Base) -> @out Result
           {
             auto getter = component.getComputedPropertyGetter();
             auto substGetterType = getter->getLoweredFunctionType()
@@ -3861,9 +3867,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             require(substGetterType->getNumParameters() == 1 + hasIndices,
                     "getter should have one parameter");
             auto baseParam = substGetterType->getParameters()[0];
-            require(baseParam.getConvention() ==
-                      ParameterConvention::Indirect_In,
-                    "getter base parameter should be @in");
+            require(baseParam.getConvention() == normalArgConvention,
+                    "getter base parameter should have normal arg convention");
             require(baseParam.getType() == loweredBaseTy.getSwiftRValueType(),
                     "getter base parameter should match base of component");
 
@@ -3889,7 +3894,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
           if (kind == KeyPathPatternComponent::Kind::SettableProperty) {
             // Setter should be
-            // <Sig...> @convention(thin) (@in Result, @in Base) -> ()
+            // <Sig...> @convention(thin) (@in_guaranteed Result, @in Base) -> ()
 
             auto setter = component.getComputedPropertySetter();
             auto substSetterType = setter->getLoweredFunctionType()
@@ -3903,16 +3908,17 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
                     "setter should have two parameters");
 
             auto newValueParam = substSetterType->getParameters()[0];
-            require(newValueParam.getConvention() ==
-                      ParameterConvention::Indirect_In,
-                    "setter value parameter should be @in");
+            // TODO: This should probably be unconditionally +1 when we
+            // can represent that.
+            require(newValueParam.getConvention() == normalArgConvention,
+                    "setter value parameter should havee normal arg convention");
 
             auto baseParam = substSetterType->getParameters()[1];
-            require(baseParam.getConvention() ==
-                      ParameterConvention::Indirect_In
+            require(baseParam.getConvention() == normalArgConvention
                     || baseParam.getConvention() ==
                         ParameterConvention::Indirect_Inout,
-                    "setter base parameter should be @in or @inout");
+                    "setter base parameter should be normal arg convention "
+                    "or @inout");
 
             if (hasIndices) {
               auto indicesParam = substSetterType->getParameters()[2];

lib/SILGen/SILGenExpr.cpp

@@ -3008,7 +3008,14 @@ emitKeyPathRValueBase(SILGenFunction &subSGF,
   if (!storage->getDeclContext()->isTypeContext())
     return ManagedValue();
 
-  auto paramOrigValue = subSGF.emitManagedRValueWithCleanup(paramArg);
+  ManagedValue paramOrigValue;
+  
+  if (subSGF.SGM.M.getOptions().EnableGuaranteedNormalArguments) {
+    paramOrigValue =
+      ManagedValue::forBorrowedRValue(paramArg).copy(subSGF, loc);
+  } else {
+    paramOrigValue = subSGF.emitManagedRValueWithCleanup(paramArg);
+  }
   auto paramSubstValue = subSGF.emitOrigToSubstValue(loc, paramOrigValue,
                                              AbstractionPattern::getOpaque(),
                                              baseType);
@@ -3107,9 +3114,15 @@ static SILFunction *getOrCreateKeyPathGetter(SILGenModule &SGM,
                                              propertyType);
   }
 
+  ParameterConvention paramConvention;
+  if (SGM.M.getOptions().EnableGuaranteedNormalArguments)
+    paramConvention = ParameterConvention::Indirect_In_Guaranteed;
+  else
+    paramConvention = ParameterConvention::Indirect_In;
+
   SmallVector<SILParameterInfo, 2> params;
   params.push_back({loweredBaseTy.getSwiftRValueType(),
-                    ParameterConvention::Indirect_In});
+                    paramConvention});
   auto &C = SGM.getASTContext();
   if (!indexes.empty())
     params.push_back({C.getUnsafeRawPointerDecl()->getDeclaredType()
@@ -3224,15 +3237,21 @@ SILFunction *getOrCreateKeyPathSetter(SILGenModule &SGM,
 
   auto &C = SGM.getASTContext();
 
+  ParameterConvention paramConvention;
+  if (SGM.M.getOptions().EnableGuaranteedNormalArguments)
+    paramConvention = ParameterConvention::Indirect_In_Guaranteed;
+  else
+    paramConvention = ParameterConvention::Indirect_In;
+
   SmallVector<SILParameterInfo, 3> params;
   // property value
   params.push_back({loweredPropTy.getSwiftRValueType(),
-                    ParameterConvention::Indirect_In});
+                    paramConvention});
   // base
   params.push_back({loweredBaseTy.getSwiftRValueType(),
                     property->isSetterMutating()
                       ? ParameterConvention::Indirect_Inout
-                      : ParameterConvention::Indirect_In});
+                      : paramConvention});
   // indexes
   if (!indexes.empty())
     params.push_back({C.getUnsafeRawPointerDecl()->getDeclaredType()
@@ -3298,7 +3317,12 @@ SILFunction *getOrCreateKeyPathSetter(SILGenModule &SGM,
                                                          indexes,
                                                          indexPtrArg);
 
-  auto valueOrig = subSGF.emitManagedRValueWithCleanup(valueArg);
+  ManagedValue valueOrig;
+  if (SGM.M.getOptions().EnableGuaranteedNormalArguments)
+    valueOrig = ManagedValue::forBorrowedRValue(valueArg)
+      .copy(subSGF, loc);
+  else
+    valueOrig = subSGF.emitManagedRValueWithCleanup(valueArg);
   auto valueSubst = subSGF.emitOrigToSubstValue(loc, valueOrig,
                                                 AbstractionPattern::getOpaque(),
                                                 propertyType);