Sema: Split off checkPatternBindingCaptures() from computeCaptures()

Store the captures for each stored property initializer separately,
instead of incorporating them into the capture list of each
designated initializer.

Fixes <rdar://problem/41490541>

Author: slavapestov

include/swift/AST/Decl.h

@@ -1931,6 +1931,9 @@ class PatternBindingEntry {
   /// The initializer context used for this pattern binding entry.
   llvm::PointerIntPair<DeclContext *, 1, bool> InitContextAndIsText;
 
+  /// Values captured by this initializer.
+  CaptureInfo Captures;
+
   friend class PatternBindingInitializer;
 
 public:
@@ -2024,6 +2027,9 @@ class PatternBindingEntry {
   /// \param omitAccessors Whether the computation should omit the accessors
   /// from the source range.
   SourceRange getSourceRange(bool omitAccessors = false) const;
+
+  const CaptureInfo &getCaptureInfo() const { return Captures; }
+  void setCaptureInfo(const CaptureInfo &captures) { Captures = captures; }
 };
 
 /// This decl contains a pattern and optional initializer for a set
@@ -2121,6 +2127,18 @@ class PatternBindingDecl final : public Decl,
 
   void setPattern(unsigned i, Pattern *Pat, DeclContext *InitContext);
 
+  DeclContext *getInitContext(unsigned i) const {
+    return getPatternList()[i].getInitContext();
+  }
+
+  const CaptureInfo &getCaptureInfo(unsigned i) const {
+    return getPatternList()[i].getCaptureInfo();
+  }
+
+  void setCaptureInfo(unsigned i, const CaptureInfo &captures) {
+    getMutablePatternList()[i].setCaptureInfo(captures);
+  }
+
   /// Given that this PBD is the parent pattern for the specified VarDecl,
   /// return the entry of the VarDecl in our PatternList.  For example, in:
   ///

lib/SILGen/SILGen.cpp

@@ -1132,6 +1132,7 @@ emitStoredPropertyInitialization(PatternBindingDecl *pbd, unsigned i) {
   auto *var = pbdEntry.getAnchoringVarDecl();
   auto *init = pbdEntry.getInit();
   auto *initDC = pbdEntry.getInitContext();
+  auto &captureInfo = pbdEntry.getCaptureInfo();
   assert(!pbdEntry.isInitializerSubsumed());
 
   // If this is the backing storage for a property with an attached wrapper
@@ -1148,12 +1149,23 @@ emitStoredPropertyInitialization(PatternBindingDecl *pbd, unsigned i) {
 
   SILDeclRef constant(var, SILDeclRef::Kind::StoredPropertyInitializer);
   emitOrDelayFunction(*this, constant,
-                      [this,constant,init,initDC](SILFunction *f) {
+                      [this,var,captureInfo,constant,init,initDC](SILFunction *f) {
     preEmitFunction(constant, init, f, init);
     PrettyStackTraceSILFunction X("silgen emitStoredPropertyInitialization", f);
     f->createProfiler(init, constant, ForDefinition);
-    SILGenFunction(*this, *f, initDC)
-        .emitGeneratorFunction(constant, init, /*EmitProfilerIncrement=*/true);
+    SILGenFunction SGF(*this, *f, initDC);
+
+    // If this is a stored property initializer inside a type at global scope,
+    // it may close over a global variable. If we're emitting top-level code,
+    // then emit a "mark_function_escape" that lists the captured global
+    // variables so that definite initialization can reason about this
+    // escape point.
+    if (!var->getDeclContext()->isLocalContext() &&
+        TopLevelSGF && TopLevelSGF->B.hasValidInsertionPoint()) {
+      emitMarkFunctionEscapeForTopLevelCodeGlobals(var, captureInfo);
+    }
+
+    SGF.emitGeneratorFunction(constant, init, /*EmitProfilerIncrement=*/true);
     postEmitFunction(constant, f);
   });
 }

lib/Sema/TypeCheckCaptures.cpp

@@ -627,37 +627,12 @@ void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
                           AFR.getAsDeclContext(),
                           AFR.isKnownNoEscape(),
                           AFR.isObjC());
-  if (AFR.getBody())
-    AFR.getBody()->walk(finder);
+  AFR.getBody()->walk(finder);
 
   if (AFR.hasType() && !AFR.isObjC()) {
     finder.checkType(AFR.getType(), AFR.getLoc());
   }
 
-  // If this is an init(), explicitly walk the initializer values for members of
-  // the type.  They will be implicitly emitted by SILGen into the generated
-  // initializer.
-  if (auto CD =
-        dyn_cast_or_null<ConstructorDecl>(AFR.getAbstractFunctionDecl())) {
-    auto *typeDecl = dyn_cast<NominalTypeDecl>(CD->getDeclContext());
-    if (typeDecl && CD->isDesignatedInit()) {
-      for (auto member : typeDecl->getMembers()) {
-        // Ignore everything other than PBDs.
-        auto *PBD = dyn_cast<PatternBindingDecl>(member);
-        if (!PBD) continue;
-        // Walk the initializers for all properties declared in the type with
-        // an initializer.
-        for (auto &elt : PBD->getPatternList()) {
-          if (elt.isInitializerSubsumed())
-            continue;
-
-          if (auto *init = elt.getInit())
-            init->walk(finder);
-        }
-      }
-    }
-  }
-
   auto captures = finder.getCaptureInfo();
 
   // A generic function always captures outer generic parameters.
@@ -700,3 +675,31 @@ void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
     for (auto *expr : cFunctionPointers->second)
       maybeDiagnoseCaptures(expr, AFR);
 }
+
+void TypeChecker::checkPatternBindingCaptures(NominalTypeDecl *typeDecl) {
+  for (auto member : typeDecl->getMembers()) {
+    // Ignore everything other than PBDs.
+    auto *PBD = dyn_cast<PatternBindingDecl>(member);
+    if (!PBD) continue;
+    // Walk the initializers for all properties declared in the type with
+    // an initializer.
+    for (unsigned i = 0, e = PBD->getNumPatternEntries(); i < e; ++i) {
+      if (PBD->isInitializerSubsumed(i))
+        continue;
+
+      auto *init = PBD->getInit(i);
+      if (init == nullptr)
+        continue;
+
+      FindCapturedVars finder(*this,
+                              init->getLoc(),
+                              PBD->getInitContext(i),
+                              /*NoEscape=*/false,
+                              /*ObjC=*/false);
+      init->walk(finder);
+
+      auto captures = finder.getCaptureInfo();
+      PBD->setCaptureInfo(i, captures);
+    }
+  }
+}

lib/Sema/TypeCheckDecl.cpp

@@ -2829,6 +2829,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     for (Decl *Member : SD->getMembers())
       visit(Member);
 
+    TC.checkPatternBindingCaptures(SD);
+
     TC.checkDeclAttributes(SD);
 
     checkInheritanceClause(SD);
@@ -2955,6 +2957,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       visit(Member);
     }
 
+    TC.checkPatternBindingCaptures(CD);
+
     // If this class requires all of its stored properties to have
     // in-class initializers, diagnose this now.
     if (CD->requiresStoredPropertyInits())
@@ -5644,10 +5648,6 @@ void TypeChecker::defineDefaultConstructor(NominalTypeDecl *decl) {
   stmts.push_back(new (Context) ReturnStmt(decl->getLoc(), nullptr));
   ctor->setBody(BraceStmt::create(Context, SourceLoc(), stmts, SourceLoc()));
   ctor->setBodyTypeCheckedIfPresent();
-
-  // FIXME: This is still needed so that DI can check captures for
-  // initializer expressions. Rethink that completely.
-  Context.addSynthesizedDecl(ctor);
 }
 
 static void validateAttributes(TypeChecker &TC, Decl *D) {

lib/Sema/TypeChecker.h

@@ -1441,6 +1441,9 @@ class TypeChecker final : public LazyResolver {
   /// Compute the set of captures for the given function or closure.
   void computeCaptures(AnyFunctionRef AFR);
 
+  /// Check for invalid captures from stored property initializers.
+  void checkPatternBindingCaptures(NominalTypeDecl *typeDecl);
+
   /// Change the context of closures in the given initializer
   /// expression to the given context.
   ///

test/SILOptimizer/definite_init_diagnostics_globals.swift

@@ -60,9 +60,8 @@ var w: String  // expected-note {{variable defined here}}
                // expected-note@-1 {{variable defined here}}
                // expected-note@-2 {{variable defined here}}
 
-// FIXME: the error should blame the class definition: <rdar://41490541>.
-class TestClass1 { // expected-error {{variable 'w' used by function definition before being initialized}}
-  let fld = w
+class TestClass1 {
+  let fld = w // expected-error {{variable 'w' used by function definition before being initialized}}
 }
 
 class TestClass2 {