[ClosureSpecializer] Bail on noncopyable argument.

The optimization currently always creates a retain of the argument.
This isn't legal for noncopyable values.

rdar://129622373

Author: nate-chandler

lib/SILOptimizer/IPO/ClosureSpecializer.cpp

@@ -576,24 +576,30 @@ static bool isSupportedClosure(const SILInstruction *Closure) {
     return false;
 
   if (auto *PAI = dyn_cast<PartialApplyInst>(Closure)) {
-    // Bail if any of the arguments are passed by address and
-    // are not @inout.
-    // This is a temporary limitation.
+    // Check whether each argument is supported.
     auto ClosureCallee = FRI->getReferencedFunction();
     auto ClosureCalleeConv = ClosureCallee->getConventions();
     unsigned ClosureArgIdxBase =
         ClosureCalleeConv.getNumSILArguments() - PAI->getNumArguments();
     for (auto pair : llvm::enumerate(PAI->getArguments())) {
       auto Arg = pair.value();
       auto ClosureArgIdx = pair.index() + ClosureArgIdxBase;
+      auto ArgConvention =
+          ClosureCalleeConv.getSILArgumentConvention(ClosureArgIdx);
+
       SILType ArgTy = Arg->getType();
+      // Specializing (currently) always produces a retain in the caller.
+      // That's not allowed for values of move-only type.
+      if (ArgTy.isMoveOnly()) {
+        return false;
+      }
+
+      // Only @inout/@inout_aliasable addresses are (currently) supported.
       // If our argument is an object, continue...
       if (ArgTy.isObject()) {
         ++ClosureArgIdx;
         continue;
       }
-      auto ArgConvention =
-          ClosureCalleeConv.getSILArgumentConvention(ClosureArgIdx);
       if (ArgConvention != SILArgumentConvention::Indirect_Inout &&
           ArgConvention != SILArgumentConvention::Indirect_InoutAliasable)
         return false;

test/SILOptimizer/closure_specialize.sil

@@ -938,3 +938,35 @@ bb0(%0 : $Int):
   %empty = tuple ()
   return %empty : $()
 }
+
+struct NC : ~Copyable {
+  deinit {}
+}
+
+sil hidden [noinline] @noncopyable_arg_closure : $@convention(thin) (@guaranteed NC) -> () {
+bb0(%0 : $NC):
+  %retval = tuple ()
+  return %retval : $()
+}
+
+sil hidden [noinline] @use_noncopyable_arg_closure : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> () {
+bb0(%0 : $@noescape @callee_guaranteed () -> ()):
+  %2 = apply %0() : $@noescape @callee_guaranteed () -> ()
+  %3 = tuple ()
+  return %3 : $()
+}
+
+// Ensure that a retain_value of a noncopyable value isn't created.
+// CHECK-LABEL: sil @dont_specialize_noncopyable_arg_closure : {{.*}} {
+// CHECK-NOT:     retain_value {{%.*}} : $NC
+// CHECK-LABEL: } // end sil function 'dont_specialize_noncopyable_arg_closure'
+sil @dont_specialize_noncopyable_arg_closure : $@convention(thin) (@guaranteed NC) -> () {
+bb0(%nc : $NC):
+  %closure_fn = function_ref @noncopyable_arg_closure : $@convention(thin) (@guaranteed NC) -> ()
+  %closure = partial_apply [callee_guaranteed] [on_stack] %closure_fn(%nc) : $@convention(thin) (@guaranteed NC) -> ()
+  %use = function_ref @use_noncopyable_arg_closure : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+  apply %use(%closure) : $@convention(thin) (@noescape @callee_guaranteed () -> ()) -> ()
+  dealloc_stack %closure : $@noescape @callee_guaranteed () -> ()
+  %11 = tuple ()
+  return %11 : $()
+}