[move-only] If we diagnose an invalid escaping capture, turn off noncopyable checking in the closure.

The reason why I am doing this is that currently SILGen knows when emitting said
closure that we are going to emit an error (that it does not have enough
information to emit itself since it doesn't know the caller), so doesn't emit
move checking markers. The result is that the move checker will not eliminate
any copies in the closure and thus will emit a "copy of noncopyable type found"
error and tell the user to file a bug. This just suppresses that.

The tests for this go with the next commit.

Author: gottesmm

include/swift/AST/SemanticAttrs.def

@@ -127,8 +127,21 @@ SEMANTICS_ATTR(LIFETIMEMANAGEMENT_COPY, "lifetimemanagement.copy")
 
 SEMANTICS_ATTR(NO_PERFORMANCE_ANALYSIS, "no_performance_analysis")
 
-// A flag used to turn off moveonly diagnostics on functions that allocbox to
-// stack specialized.
+// A flag used to turn off moveonly diagnostics on a function due to an earlier
+// pass that ran.
+//
+// DISCUSSION: This is used in a few situations:
+//
+// 1. When allocbox to stack specializes a function, we do not want to emit move
+// errors twice, once on the specialized and once on the original
+// function. Instead, we put this on the original function.
+//
+// 2. If we emit a diagnose invalid escaping captures error due to an inout
+// being escaped into an escaping closure, we do not want to emit move errors in
+// the closure. This is because SILGen today assumes that we will error in such
+// cases and thus does not emit markers in said function for the inout. This
+// then causes us to emit spurious "found a copy of a noncopyable value" errors
+// that may cause the user to think there is a bug in the compiler.
 SEMANTICS_ATTR(NO_MOVEONLY_DIAGNOSTICS, "sil.optimizer.moveonly.diagnostic.ignore")
 
 #undef SEMANTICS_ATTR

lib/SILOptimizer/Mandatory/DiagnoseInvalidEscapingCaptures.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/Expr.h"
 #include "swift/AST/Types.h"
 #include "swift/SIL/ApplySite.h"
+#include "swift/AST/SemanticAttrs.h"
 #include "swift/SIL/InstructionUtils.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBasicBlock.h"
@@ -396,18 +397,24 @@ static void checkPartialApply(ASTContext &Context, DeclContext *DC,
       }
     }
   }
+
+  bool emittedError = false;
+
   // First, diagnose the inout captures, if any.
   for (auto inoutCapture : inoutCaptures) {
     Optional<Identifier> paramName = None;
     if (isUseOfSelfInInitializer(inoutCapture)) {
+      emittedError = true;
       diagnose(Context, PAI->getLoc(), diag::escaping_mutable_self_capture,
                functionKind);
     } else {
       auto *param = getParamDeclFromOperand(inoutCapture->get());
-      if (param->isSelfParameter())
+      if (param->isSelfParameter()) {
+        emittedError = true;
         diagnose(Context, PAI->getLoc(), diag::escaping_mutable_self_capture,
                  functionKind);
-      else {
+      } else {
+        emittedError = true;
         paramName = param->getName();
         diagnose(Context, PAI->getLoc(), diag::escaping_inout_capture,
                  functionKind, param->getName());
@@ -416,31 +423,46 @@ static void checkPartialApply(ASTContext &Context, DeclContext *DC,
       }
     }
     if (functionKind != EscapingAutoClosure) {
+      emittedError = true;
       diagnoseCaptureLoc(Context, DC, PAI, inoutCapture);
       continue;
     }
     // For an autoclosure capture, present a way to fix the problem.
-    if (paramName)
+    if (paramName) {
+      emittedError = true;
       diagnose(Context, PAI->getLoc(), diag::copy_inout_captured_by_autoclosure,
                paramName.value());
-    else
+    } else {
+      emittedError = true;
       diagnose(Context, PAI->getLoc(), diag::copy_self_captured_by_autoclosure);
+    }
   }
 
   // Finally, diagnose captures of values with noescape type.
   for (auto noEscapeCapture : noEscapeCaptures) {
     if (auto *param = getParamDeclFromOperand(noEscapeCapture->get())) {
+      emittedError = true;
       diagnose(Context, PAI->getLoc(), diag::escaping_noescape_param_capture,
                functionKind, param->getName());
       diagnose(Context, param->getLoc(), diag::noescape_param_defined_here,
                param->getName());
     } else {
+      emittedError = true;
       diagnose(Context, PAI->getLoc(), diag::escaping_noescape_var_capture,
                functionKind);
     }
 
     diagnoseCaptureLoc(Context, DC, PAI, noEscapeCapture);
   }
+
+  // If we emitted an error, mark the closure function as not being suitable for
+  // noncopyable diagnostics. The user can fix the issue and then recompile.
+  if (emittedError) {
+    if (auto *f = apply.getCalleeFunction()) {
+      auto s = semantics::NO_MOVEONLY_DIAGNOSTICS;
+      f->addSemanticsAttr(s);
+    }
+  }
 }
 
 // Enforce exclusivity restrictions on recursive uses of non-escaping closures.
@@ -539,7 +561,7 @@ static void checkEscapingCaptures(SILFunction *F) {
   if (F->empty())
     return;
 
-  auto &Context =F->getASTContext();
+  auto &Context = F->getASTContext();
   auto *DC = F->getDeclContext();
 
   for (auto &BB : *F) {

lib/SILOptimizer/Mandatory/MoveOnlyChecker.cpp

@@ -157,7 +157,7 @@ class MoveOnlyCheckerPass : public SILFunctionTransform {
     assert(fn->getModule().getStage() == SILStage::Raw &&
            "Should only run on Raw SIL");
 
-    // If allocbox to stack told use to not emit diagnostics for this function,
+    // If an earlier pass told use to not emit diagnostics for this function,
     // clean up any copies, invalidate the analysis, and return early.
     if (getFunction()->hasSemanticsAttr(semantics::NO_MOVEONLY_DIAGNOSTICS)) {
       if (cleanupNonCopyableCopiesAfterEmittingDiagnostic(getFunction()))