[Property delegates] Contextualize direct initializers of custom attributes

When a custom attribute is given a direct initializer, save and re-use
the initializer context we create so that it can be associated with the
enclosing pattern binding. Fixes assertions involving explicit closures
in property delegates.

Author: DougGregor

lib/Parse/ParseDecl.cpp

@@ -1711,6 +1711,18 @@ bool Parser::parseVersionTuple(llvm::VersionTuple &Version,
   return false;
 }
 
+/// Check whether the attributes have already established an initializer
+/// context within the given set of attributes.
+static PatternBindingInitializer *findAttributeInitContent(
+    DeclAttributes &Attributes) {
+  for (auto custom : Attributes.getAttributes<CustomAttr>()) {
+    if (auto initContext = custom->getInitContext())
+      return initContext;
+  }
+
+  return nullptr;
+}
+
 /// \verbatim
 ///   attribute:
 ///     '_silgen_name' '(' identifier ')'
@@ -1853,7 +1865,10 @@ bool Parser::parseDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc) {
       // DeclContexts for any closures that may live inside of initializers.
       Optional<ParseFunctionBody> initParser;
       if (!CurDeclContext->isLocalContext()) {
-        initContext = new (Context) PatternBindingInitializer(CurDeclContext);
+        initContext = findAttributeInitContent(Attributes);
+        if (!initContext)
+          initContext = new (Context) PatternBindingInitializer(CurDeclContext);
+
         initParser.emplace(*this, initContext);
       }
 
@@ -5242,10 +5257,14 @@ Parser::parseDeclVar(ParseDeclOptions Flags,
       }
     });
 
+    // Check whether we have already established an initializer context.
+    PatternBindingInitializer *initContext =
+      findAttributeInitContent(Attributes);
+
     // Remember this pattern/init pair for our ultimate PatternBindingDecl. The
     // Initializer will be added later when/if it is parsed.
     PBDEntries.push_back({pattern, /*EqualLoc*/ SourceLoc(), /*Init*/ nullptr,
-                          /*InitContext*/ nullptr});
+                          initContext});
 
     Expr *PatternInit = nullptr;
 
@@ -5255,7 +5274,6 @@ Parser::parseDeclVar(ParseDeclOptions Flags,
       // If we're not in a local context, we'll need a context to parse initializers
       // into (should we have one).  This happens for properties and global
       // variables in libraries.
-      PatternBindingInitializer *initContext = nullptr;
 
       // Record the variables that we're trying to initialize.  This allows us
       // to cleanly reject "var x = x" when "x" isn't bound to an enclosing

lib/Sema/TypeCheckStmt.cpp

@@ -49,6 +49,26 @@ using namespace swift;
 
 #define DEBUG_TYPE "TypeCheckStmt"
 
+#ifndef NDEBUG
+/// Determine whether the given context is for the backing property of a
+/// property delegate.
+static bool isPropertyDelegateBackingInitContext(DeclContext *dc) {
+  auto initContext = dyn_cast<Initializer>(dc);
+  if (!initContext) return false;
+
+  auto patternInitContext = dyn_cast<PatternBindingInitializer>(initContext);
+  if (!patternInitContext) return false;
+
+  auto binding = patternInitContext->getBinding();
+  if (!binding) return false;
+
+  auto singleVar = binding->getSingleVar();
+  if (!singleVar) return false;
+
+  return singleVar->getOriginalDelegatedProperty() != nullptr;
+}
+#endif
+
 namespace {
   class ContextualizeClosures : public ASTWalker {
     DeclContext *ParentDC;
@@ -116,8 +136,9 @@ namespace {
               ParentDC->getContextKind() != DeclContextKind::TopLevelCodeDecl) {
             // If a closure is nested within an auto closure, we'll need to update
             // its parent to the auto closure parent.
-            assert(ParentDC->getContextKind() ==
-                   DeclContextKind::AbstractClosureExpr &&
+            assert((ParentDC->getContextKind() ==
+                      DeclContextKind::AbstractClosureExpr ||
+                    isPropertyDelegateBackingInitContext(ParentDC)) &&
                    "Incorrect parent decl context for closure");
             CE->setParent(ParentDC);
           }

test/decl/var/property_delegates.swift

@@ -28,6 +28,10 @@ struct WrapperAcceptingAutoclosure<T> {
   init(initialValue fn: @autoclosure @escaping () -> T) {
     self.fn = fn
   }
+
+  init(body fn: @escaping () -> T) {
+    self.fn = fn
+  }
 }
 
 @propertyDelegate
@@ -652,3 +656,14 @@ struct S {
   @BrokenLazy // expected-error{{struct 'BrokenLazy' cannot be used as an attribute}}
   var value: Int
 }
+
+// ---------------------------------------------------------------------------
+// Closures in initializers
+// ---------------------------------------------------------------------------
+struct UsesExplicitClosures {
+  @WrapperAcceptingAutoclosure(body: { 42 })
+  var x: Int
+
+  @WrapperAcceptingAutoclosure(body: { return 42 })
+  var y: Int
+}