ConstantCapturePropagation: don't propagate keypaths with multiple uses in non-OSSA

We cannot do this because we don't know where to insert the compensating release after the propagated `partial_apply`.
A required `strong_retain` may have been moved over the `partial_apply`.
Then we would release the keypath too early.

Fixes a mis-compile
rdar://161321614

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ConstantCapturePropagation.swift

@@ -305,7 +305,9 @@ private extension PartialApplyInst {
     var nonConstArgs = [Operand]()
     var hasKeypath = false
     for argOp in argumentOperands {
-      switch argOp.value.isConstant() {
+      // In non-OSSA we don't know where to insert the compensating release for a propagated keypath.
+      // Therefore bail if a keypath has multiple uses.
+      switch argOp.value.isConstant(requireSingleUse: !parentFunction.hasOwnership && !isOnStack) {
       case .constant:
         constArgs.append(argOp)
       case .constantWithKeypath:
@@ -357,26 +359,33 @@ private enum ConstantKind {
 }
 
 private extension Value {
-  func isConstant() -> ConstantKind {
+  func isConstant(requireSingleUse: Bool) -> ConstantKind {
     // All instructions handled here must also be handled in
     // `FunctionSignatureSpecializationMangler::mangleConstantProp`.
+    let result: ConstantKind
     switch self {
     case let si as StructInst:
-      return si.operands.reduce(.constant, { $0.merge(with: $1.value.isConstant()) })
+      result = si.operands.reduce(.constant, {
+        $0.merge(with: $1.value.isConstant(requireSingleUse: requireSingleUse))
+      })
     case is ThinToThickFunctionInst, is ConvertFunctionInst, is UpcastInst, is OpenExistentialRefInst:
-      return (self as! UnaryInstruction).operand.value.isConstant()
+      result = (self as! UnaryInstruction).operand.value.isConstant(requireSingleUse: requireSingleUse)
     case is StringLiteralInst, is IntegerLiteralInst, is FloatLiteralInst, is FunctionRefInst, is GlobalAddrInst:
-      return .constant
+      result = .constant
     case let keyPath as KeyPathInst:
       guard keyPath.operands.isEmpty,
             keyPath.hasPattern,
             !keyPath.substitutionMap.hasAnySubstitutableParams
       else {
         return .notConstant
       }
-      return .constantWithKeypath
+      result = .constantWithKeypath
     default:
       return .notConstant
     }
+    if requireSingleUse, result == .constantWithKeypath, !uses.ignoreDebugUses.isSingleUse {
+      return .notConstant
+    }
+    return result
   }
 }

test/SILOptimizer/capture_propagation.sil

@@ -558,6 +558,29 @@ bb0:
   return %7 : $()
 }
 
+// CHECK-LABEL: sil @dontPropagateMulitUseKeyPathInNonOSSA :
+// CHECK:         %0 = keypath
+// CHECK:         [[U:%.*]] = upcast %0
+// CHECK:         [[C:%.*]] = function_ref @closureWithKeypath
+// CHECK:         partial_apply [callee_guaranteed] [[C]]([[U]])
+// CHECK:       } // end sil function 'dontPropagateMulitUseKeyPathInNonOSSA'
+sil @dontPropagateMulitUseKeyPathInNonOSSA : $@convention(thin) () -> () {
+bb0:
+  %0 = keypath $WritableKeyPath<Str, Int>, (root $Str; stored_property #Str.a : $Int)
+  %c = upcast %0 to $KeyPath<Str, Int>
+  %1 = function_ref @closureWithKeypath : $@convention(thin) (Str, @guaranteed KeyPath<Str, Int>) -> Int
+  %2 = partial_apply [callee_guaranteed] %1(%c) : $@convention(thin) (Str, @guaranteed KeyPath<Str, Int>) -> Int
+  strong_retain %0
+  %3 = convert_escape_to_noescape %2 : $@callee_guaranteed (Str) -> Int to $@noescape @callee_guaranteed (Str) -> Int
+  %4 = function_ref @calleeWithKeypath : $@convention(thin) (@noescape @callee_guaranteed (Str) -> Int) -> ()
+  %5 = apply %4(%3) : $@convention(thin) (@noescape @callee_guaranteed (Str) -> Int) -> ()
+  strong_release %2 : $@callee_guaranteed (Str) -> Int
+  strong_release %0
+  %7 = tuple ()
+  return %7 : $()
+}
+
+
 // CHECK-LABEL: sil shared @$s18closureWithKeypath{{.*}}main3StrVSiTf3npk_n : $@convention(thin) (Str) -> Int {
 // CHECK:         [[K:%[0-9]+]] = keypath
 // CHECK:         [[F:%[0-9]+]] = function_ref @swift_getAtKeyPath