[TypeChecker] PropertyWrappers: Re-parent any captures from wrapped to backing property

In the situations where initializer of property wrapper attribute
has any kind of captures i.e. `{ [x = ...] ... }` they should be
re-parented to the backing property because that's actually
where the expression gets used - initializer of the backing
property, e.g:

```swift
struct Test {
  @wrapper([1, 2, 3].map { [x = 42] ... })
  var x: Int
}
```

is transformed into:

```swift
struct Test {
  var x: Int {
    get { ... }
    set { ... }
  }

  var _x: Wrapper<Int> = Wrapper(wrappedValue: [1, 2, 3].map { [x = 42] ... })
}
```

Resolves: #61570
Resolves: rdar://problem/101813792

Author: xedin

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
+  }
+}