Fix issue where implicit self was unexpectedly not allowed in nested weak self closure in Swift 6 mode

Author: calda

lib/Sema/MiscDiagnostics.cpp

@@ -1901,9 +1901,21 @@ static void diagnoseImplicitSelfUseInClosure(const Expr *E,
       // If this closure has a `weak self` capture, require that the
       // closure unwraps self. If not, implicit self is not allowed
       // in this closure or in any nested closure.
-      if (closureHasWeakSelfCapture(inClosure) &&
-          !hasValidSelfRebinding(parentConditionalStmt(selfDecl), ctx)) {
-        return false;
+      if (closureHasWeakSelfCapture(inClosure)) {
+        // If a `guard let self` or `if let self` unbinding condition exists,
+        // then it must not be invalid.
+        if (auto condStmt = parentConditionalStmt(selfDecl)) {
+          if (!hasValidSelfRebinding(condStmt, ctx)) {
+            return false;
+          }
+        }
+
+        // If the self decl hasn't been unwrapped, then this closure is
+        // invalid unless non-unwrapped weak self is explicitly enabled
+        // in this situation.
+        else if (validateSelfRebindings) {
+          return false;
+        }
       }
 
       if (auto autoclosure = dyn_cast<AutoClosureExpr>(inClosure)) {
@@ -2050,10 +2062,15 @@ static void diagnoseImplicitSelfUseInClosure(const Expr *E,
           // Check whether implicit self is disallowed due to this specific
           // closure, or if its disallowed due to some parent of this closure,
           // so we can return the specific closure that is invalid.
+          //
+          // If this is a `weak self` capture, we don't need to validate that
+          // that capture has been unwrapped in a `let self = self` binding
+          // within the parent closure. A self rebinding in this inner closure
+          // is sufficient to enable implicit self.
           if (!selfDeclAllowsImplicitSelf(outerSelfDecl, captureType,
                                           outerClosure,
                                           /*validateParentClosures:*/ false,
-                                          /*validateSelfRebindings:*/ true)) {
+                                          /*validateSelfRebindings:*/ false)) {
             return outerClosure;
           }
 

test/expr/closure/closures_swift6.swift

@@ -454,6 +454,92 @@ class TestGithubIssue70089 {
         }
       }
     }
+
+    func testClosuresInsideWeakSelfNotUnwrapped() {
+      // https://forums.swift.org/t/nested-weak-capture-and-implicit-self-in-swift-6/77230/1
+      doVoidStuff { [weak self] in
+        doVoidStuff { [weak self] in
+          guard let self else { return }
+          x += 1
+        }
+      }
+
+      doVoidStuff { [weak self] in
+        doVoidStuff { [weak self] in
+          doVoidStuff { [weak self] in
+            guard let self else { return }
+            doVoidStuff { [weak self] in
+              doVoidStuff { [weak self] in
+                guard let self else { return }
+                x += 1
+              }
+            }
+          }
+        }
+      }
+
+      doVoidStuff { [weak self] in
+        doVoidStuff { [weak self] in
+          guard let self else { return }
+          doVoidStuff { [self] in
+            doVoidStuff { [self] in
+              doVoidStuff { [weak self] in
+                guard let self else { return }
+                x += 1
+              }
+            }
+          }
+        }
+      }
+
+      doVoidStuff { [weak self] in
+        guard let self = self ?? TestGithubIssue70089.staticOptional else { return }
+        doVoidStuff { [weak self] in
+          guard let self else { return }
+          x += 1 // expected-error{{reference to property 'x' in closure requires explicit use of 'self' to make capture semantics explicit}}
+        }
+      }
+
+      doVoidStuff { [weak self] in
+        doVoidStuff { [self] in
+          x += 1 // expected-error@-1 {{value of optional type 'TestGithubIssue70089?' must be unwrapped to a value of type 'TestGithubIssue70089'}} expected-note@-1 {{coalesce using '??' to provide a default when the optional value contains 'nil'}} expected-note@-1 {{force-unwrap using '!' to abort execution if the optional value contains 'nil'}}
+        }
+      }
+
+      doVoidStuff { [weak self] in
+        doVoidStuff { [self] in // 
+          self.x += 1 // expected-error@-1 {{value of optional type 'TestGithubIssue70089?' must be unwrapped to a value of type 'TestGithubIssue70089'}} expected-note@-1 {{coalesce using '??' to provide a default when the optional value contains 'nil'}} expected-note@-1 {{force-unwrap using '!' to abort execution if the optional value contains 'nil'}}
+        }
+      }
+
+      doVoidStuff { [weak self] in
+        doVoidStuff { [self] in
+          self?.x += 1
+        }
+      }
+
+      doVoidStuff { [weak self] in
+        doVoidStuff { [self] in
+          guard let self else { return }
+          self.x += 1
+        }
+      }
+
+      doVoidStuff { [weak self] in
+        doVoidStuff { [self] in
+          guard let self else { return }
+          x += 1
+        }
+      }
+
+      doVoidStuff { [weak self] in
+        guard let self = self ?? TestGithubIssue70089.staticOptional else { return }
+        doVoidStuff { [self] in
+          guard let self else { return } // expected-error{{initializer for conditional binding must have Optional type, not 'TestGithubIssue70089'}}
+          x += 1 // expected-error{{reference to property 'x' in closure requires explicit use of 'self' to make capture semantics explicit}}
+        }
+      }
+    }
 }
 
 class TestGithubIssue69911 {
@@ -670,7 +756,7 @@ final class AutoclosureTests {
     doVoidStuff { [weak self] in
       doVoidStuff { [self] in
         guard let self else { return }
-        method() // expected-error {{call to method 'method' in closure requires explicit use of 'self' to make capture semantics explicit}}
+        method()
       }
     }
 
@@ -702,13 +788,6 @@ final class AutoclosureTests {
       }
     }
 
-    doVoidStuff { [weak self] in
-      doVoidStuff { [self] in
-        guard let self else { return }
-        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 = self else { return }
       doVoidStuff { // expected-note {{capture 'self' explicitly to enable implicit 'self' in this closure}}