Concurrency: Contextualize initializers before checking actor isolation

Otherwise, we'll miss captures inside closures inside stored property
initializer expressions.

Author: slavapestov

lib/Sema/TypeCheckConcurrency.cpp

@@ -5369,11 +5369,9 @@ DefaultInitializerIsolation::evaluate(Evaluator &evaluator,
       return ActorIsolation::forUnspecified();
 
     auto i = pbd->getPatternEntryIndexForVarDecl(var);
-    if (!pbd->isInitializerChecked(i))
-      TypeChecker::typeCheckPatternBinding(pbd, i);
 
     dc = cast<Initializer>(pbd->getInitContext(i));
-    initExpr = pbd->getInit(i);
+    initExpr = pbd->getCheckedAndContextualizedInit(i);
     enclosingIsolation = getActorIsolation(var);
   } else if (auto *param = dyn_cast<ParamDecl>(var)) {
     // If this parameter corresponds to a stored property for a

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2722,7 +2722,16 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
         // Trigger a request that will complete typechecking for the
         // initializer.
-        (void)PBD->getCheckedAndContextualizedInit(i);
+        (void) PBD->getCheckedAndContextualizedInit(i);
+
+        if (auto *var = PBD->getSingleVar()) {
+          if (var->hasAttachedPropertyWrapper())
+            return;
+        }
+
+        if (!PBD->getDeclContext()->isLocalContext()) {
+          (void) PBD->getInitializerIsolation(i);
+        }
       }
     }
 

lib/Sema/TypeCheckStorage.cpp

@@ -617,7 +617,6 @@ static void checkAndContextualizePatternBindingInit(PatternBindingDecl *binding,
   if (auto *initContext = binding->getInitContext(i)) {
     auto *init = binding->getInit(i);
     TypeChecker::contextualizeInitializer(initContext, init);
-    (void)binding->getInitializerIsolation(i);
     TypeChecker::checkInitializerEffects(initContext, init);
   }
 }

test/Concurrency/sendable_checking_captures.swift

@@ -0,0 +1,25 @@
+// RUN: %target-typecheck-verify-swift -swift-version 6
+
+class NonSendable {} // expected-note 3{{class 'NonSendable' does not conform to the 'Sendable' protocol}}
+
+func callee(_: @Sendable () -> NonSendable) {}
+
+var testLocalCaptures: Int {
+  let ns = NonSendable()
+
+  @Sendable func localFunc() -> NonSendable {
+    return ns // expected-error {{capture of 'ns' with non-sendable type 'NonSendable' in a `@Sendable` local function}}
+  }
+
+  callee { return ns } // expected-error {{capture of 'ns' with non-sendable type 'NonSendable' in a `@Sendable` closure}}
+
+  return 3
+}
+
+struct Bad {
+  var c: Int = {
+    let ns = NonSendable()
+    callee { return ns } // expected-error {{capture of 'ns' with non-sendable type 'NonSendable' in a `@Sendable` closure}}
+    return 3
+  }()
+}