[TypeChecker] PropertyWrappers: Re-parent any captures from wrapped t…

lib/Sema/TypeCheckStmt.cpp

@@ -98,9 +98,13 @@ namespace {
         return Action::SkipChildren(E);
       } 
 
-      // Capture lists need to be reparented to enclosing autoclosures.
       if (auto CapE = dyn_cast<CaptureListExpr>(E)) {
-        if (isa<AutoClosureExpr>(ParentDC)) {
+        // Capture lists need to be reparented to enclosing autoclosures
+        // and/or initializers of property wrapper backing properties
+        // (because they subsume initializers associated with wrapped
+        // properties).
+        if (isa<AutoClosureExpr>(ParentDC) ||
+            isPropertyWrapperBackingPropertyInitContext(ParentDC)) {
           for (auto &Cap : CapE->getCaptureList()) {
             Cap.PBD->setDeclContext(ParentDC);
             Cap.getVar()->setDeclContext(ParentDC);
@@ -136,6 +140,21 @@ namespace {
       // variables.
       return Action::VisitChildrenIf(isa<PatternBindingDecl>(D));
     }
+
+  private:
+    static bool isPropertyWrapperBackingPropertyInitContext(DeclContext *DC) {
+      auto *init = dyn_cast<PatternBindingInitializer>(DC);
+      if (!init)
+        return false;
+
+      if (auto *PB = init->getBinding()) {
+        auto *var = PB->getSingleVar();
+        return var && var->getOriginalWrappedProperty(
+                          PropertyWrapperSynthesizedPropertyKind::Backing);
+      }
+
+      return false;
+    }
   };
 
   static DeclName getDescriptiveName(AbstractFunctionDecl *AFD) {

test/Sema/property_wrappers.swift

@@ -83,3 +83,40 @@ struct S2_58201 {
   // CHECK:            autoclosure_expr implicit type='() -> Bool' location={{.*}}.swift:[[@LINE+1]]:26 range=[{{.+}}] discriminator=1 escaping
   @W_58201 var b: Bool = false
 }
+
+// https://github.com/apple/swift/issues/61570
+// rdar://problem/101813792 - Check that captured variables are re-parented to backing var initializer
+do {
+  @propertyWrapper
+  struct Wrapper {
+    init(_: String) {}
+
+    var wrappedValue: Int { return 0 }
+  }
+
+  struct TestExplicitCapture {
+    @Wrapper("\([1,2,3].map({[x = 42] in "\($0 + x)" }).reduce("", +))")
+    var wrapped: Int // Ok, becomes var _wrapped: Wrapper<Int> = Wrapper(wrappedValue: "\([1,2,3].map({[x = 42] in "\($0 + x)" }).reduce("", +)))
+  }
+
+  @propertyWrapper
+  struct Option {
+    let help: String
+    var value: Double = 0.0
+
+    var wrappedValue: Double {
+      get { value }
+      set { value = newValue }
+    }
+  }
+
+  enum TestEnum: String, CaseIterable {
+    case hello = "hello"
+    case world = "world"
+  }
+
+  struct TestImplicitCapture {
+    @Option(help: "Values: \(TestEnum.allCases.map(\.rawValue))")
+    var value // Ok - $kp$ of key path is captured implicitly by backing variable init
+  }
+}