SIL: More descriptive diagnostic about escaping closure vs local function

Fixes <rdar://problem/50554625>.

Author: slavapestov

include/swift/AST/DiagnosticsSIL.def

@@ -130,24 +130,33 @@ ERROR(capture_before_declaration_defer,none,
 NOTE(captured_value_declared_here,none,
      "captured value declared here", ())
 
+#define SELECT_ESCAPING_CLOSURE_KIND "escaping %select{local function|closure}0"
+
 // Invalid escaping capture diagnostics.
 ERROR(escaping_inout_capture,none,
-      "escaping closure captures 'inout' parameter %0", (Identifier))
+      SELECT_ESCAPING_CLOSURE_KIND
+      " captures 'inout' parameter %1",
+      (unsigned, Identifier))
 NOTE(inout_param_defined_here,none,
      "parameter %0 is declared 'inout'", (Identifier))
 ERROR(escaping_mutable_self_capture,none,
-      "escaping closure captures mutating 'self' parameter", ())
+      SELECT_ESCAPING_CLOSURE_KIND
+      " captures mutating 'self' parameter", (unsigned))
 
 ERROR(escaping_noescape_param_capture,none,
-      "escaping closure captures non-escaping parameter %0", (Identifier))
+      SELECT_ESCAPING_CLOSURE_KIND
+      " captures non-escaping parameter %1", (unsigned, Identifier))
 NOTE(noescape_param_defined_here,none,
      "parameter %0 is implicitly non-escaping", (Identifier))
 
 ERROR(escaping_noescape_var_capture,none,
-      "escaping closure captures non-escaping value", ())
+      SELECT_ESCAPING_CLOSURE_KIND
+      " captures non-escaping value", (unsigned))
 
 NOTE(value_captured_here,none,"captured here", ())
 
+#undef SELECT_ESCAPING_CLOSURE_KIND
+
 NOTE(value_captured_transitively,none,
      "captured indirectly by this call", ())
 

lib/SILOptimizer/Mandatory/DiagnoseInvalidEscapingCaptures.cpp

@@ -323,19 +323,33 @@ static void checkPartialApply(ASTContext &Context, DeclContext *DC,
   // Otherwise, we have at least one escaping use of a partial_apply
   // capturing a non-escaping value. We need to emit diagnostics.
 
+  // Should match SELECT_ESCAPING_CLOSURE_KIND in DiagnosticsSIL.def.
+  enum {
+    EscapingLocalFunction,
+    EscapingClosure
+  } functionKind = EscapingClosure;
+
+  if (auto *F = PAI->getReferencedFunctionOrNull()) {
+    if (auto loc = F->getLocation()) {
+      if (loc.isASTNode<FuncDecl>())
+        functionKind = EscapingLocalFunction;
+    }
+  }
   // First, diagnose the inout captures, if any.
   for (auto inoutCapture : inoutCaptures) {
     if (isUseOfSelfInInitializer(inoutCapture)) {
-      diagnose(Context, PAI->getLoc(), diag::escaping_mutable_self_capture);
+      diagnose(Context, PAI->getLoc(), diag::escaping_mutable_self_capture,
+               functionKind);
     } else {
       auto *param = getParamDeclFromOperand(inoutCapture->get());
       if (param->isSelfParameter())
-        diagnose(Context, PAI->getLoc(), diag::escaping_mutable_self_capture);
+        diagnose(Context, PAI->getLoc(), diag::escaping_mutable_self_capture,
+                 functionKind);
       else {
         diagnose(Context, PAI->getLoc(), diag::escaping_inout_capture,
-                  param->getName());
+                 functionKind, param->getName());
         diagnose(Context, param->getLoc(), diag::inout_param_defined_here,
-                  param->getName());
+                 param->getName());
       }
     }
 
@@ -346,11 +360,12 @@ static void checkPartialApply(ASTContext &Context, DeclContext *DC,
   for (auto noEscapeCapture : noEscapeCaptures) {
     if (auto *param = getParamDeclFromOperand(noEscapeCapture->get())) {
       diagnose(Context, PAI->getLoc(), diag::escaping_noescape_param_capture,
-               param->getName());
+               functionKind, param->getName());
       diagnose(Context, param->getLoc(), diag::noescape_param_defined_here,
                param->getName());
     } else {
-      diagnose(Context, PAI->getLoc(), diag::escaping_noescape_var_capture);
+      diagnose(Context, PAI->getLoc(), diag::escaping_noescape_var_capture,
+               functionKind);
     }
 
     diagnoseCaptureLoc(Context, DC, PAI, noEscapeCapture);

test/SILOptimizer/invalid_escaping_captures.swift

@@ -53,7 +53,7 @@ func badLocalFunctionCaptureInOut1(x: inout Int) { // expected-note {{parameter
     x += 1 // expected-note {{captured here}}
   }
 
-  takesEscaping(local) // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+  takesEscaping(local) // expected-error {{escaping local function captures 'inout' parameter 'x'}}
 }
 
 func badLocalFunctionCaptureInOut2(x: inout Int) { // expected-note {{parameter 'x' is declared 'inout'}}
@@ -75,15 +75,15 @@ func badLocalFunctionCaptureInOut3(x: inout Int) { // expected-note {{parameter
     local1() // expected-note {{captured indirectly by this call}}
   }
 
-  takesEscaping(local2) // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+  takesEscaping(local2) // expected-error {{escaping local function captures 'inout' parameter 'x'}}
 }
 
 func badLocalFunctionCaptureNoEscape1(y: () -> ()) { // expected-note {{parameter 'y' is implicitly non-escaping}}
   func local() {
     y() // expected-note {{captured here}}
   }
 
-  takesEscaping(local) // expected-error {{escaping closure captures non-escaping parameter 'y'}}
+  takesEscaping(local) // expected-error {{escaping local function captures non-escaping parameter 'y'}}
 }
 
 func badLocalFunctionCaptureNoEscape2(y: () -> ()) { // expected-note {{parameter 'y' is implicitly non-escaping}}
@@ -105,7 +105,7 @@ func badLocalFunctionCaptureNoEscape3(y: () -> ()) { // expected-note {{paramete
     local1() // expected-note {{captured indirectly by this call}}
   }
 
-  takesEscaping(local2) // expected-error {{escaping closure captures non-escaping parameter 'y'}}
+  takesEscaping(local2) // expected-error {{escaping local function captures non-escaping parameter 'y'}}
 }
 
 func badLocalFunctionCaptureNoEscape4(y: () -> ()) { // expected-note {{parameter 'y' is implicitly non-escaping}}
@@ -117,7 +117,7 @@ func badLocalFunctionCaptureNoEscape4(y: () -> ()) { // expected-note {{paramete
     local1() // expected-note {{captured indirectly by this call}}
   }
 
-  takesEscaping(local2) // expected-error {{escaping closure captures non-escaping parameter 'y'}}
+  takesEscaping(local2) // expected-error {{escaping local function captures non-escaping parameter 'y'}}
 }
 
 // Capturing 'self' produces a different diagnostic.
@@ -151,7 +151,7 @@ func testGenericLocalFunctionReabstraction(x: inout Int) { // expected-note {{pa
     x += 1 // expected-note {{captured here}}
     return 0
   }
-  takesEscapingGeneric(local) // expected-error {{escaping closure captures 'inout' parameter 'x'}}
+  takesEscapingGeneric(local) // expected-error {{escaping local function captures 'inout' parameter 'x'}}
 }
 
 // Make sure that withoutActuallyEscaping counts as a safe use.