Disable SE-0365 behavior for escaping closues in Swift 5 mode

Author: calda

lib/Sema/MiscDiagnostics.cpp

@@ -1538,6 +1538,20 @@ static bool closureHasWeakSelfCapture(const AbstractClosureExpr *ACE) {
   return false;
 }
 
+/// Whether or not this closure with a `weak self` capture is permitted
+/// to use implicit self. We can't permit this for escaping closures in
+/// Swift 5 mode, because the implicit self AST in Swift 5 would cause
+/// self to be captured strongly instead of weakly.
+static bool
+allowsImplicitSelfForWeakSelfCapture(const AbstractClosureExpr *ACE) {
+  if (ACE->getASTContext().LangOpts.isSwiftVersionAtLeast(6)) {
+    return true;
+  }
+
+  return AnyFunctionRef(const_cast<AbstractClosureExpr *>(ACE))
+      .isKnownNoEscape();
+}
+
 /// Whether or not implicit self decls in this closure require manual
 /// lookup in order to perform diagnostics with the semantics described
 /// in SE-0365. This is necessary for closures that capture self weakly
@@ -1640,7 +1654,8 @@ static void diagnoseImplicitSelfUseInClosure(const Expr *E,
       // let self = .someOptionalVariable else { return }` or `let self =
       // someUnrelatedVariable`. If self hasn't been unwrapped yet and is still
       // an optional, we would have already hit an error elsewhere.
-      if (closureHasWeakSelfCapture(inClosure)) {
+      if (closureHasWeakSelfCapture(inClosure) &&
+          allowsImplicitSelfForWeakSelfCapture(inClosure)) {
         return !implicitWeakSelfReferenceIsValid(DRE, inClosure);
       }
 

test/expr/closure/closures.swift

@@ -749,21 +749,21 @@ public class TestImplicitSelfForWeakSelfCapture {
     doVoidStuff { [weak self] in
       method() // expected-error {{call to method 'method' in closure requires explicit use of 'self' to make capture semantics explicit}}
       guard let self = self else { return }
-      method()
+      method() // expected-error {{call to method 'method' in closure requires explicit use of 'self' to make capture semantics explicit}}
     }
 
     doVoidStuff { [weak self] in
       guard let self else { return }
-      method()
+      method() // expected-error {{call to method 'method' in closure requires explicit use of 'self' to make capture semantics explicit}}
     }
 
     doVoidStuff { [weak self] in
       if let self = self {
-        method()
+        method() // expected-error {{call to method 'method' in closure requires explicit use of 'self' to make capture semantics explicit}}
       }
 
       if let self {
-        method()
+        method() // expected-error {{call to method 'method' in closure requires explicit use of 'self' to make capture semantics explicit}}
       }
     }