[SILGen] Assert that captures have been computed

Before using the capture info, SILGen now asserts that it has computed, except for declarations which are not in a local context and therefore can’t have captures.

This causes failures in REPL tests, but they are actual failures—there’s a bug in TypeCheckREPL.

Author: beccadax

include/swift/SIL/TypeLowering.h

@@ -972,6 +972,24 @@ class TypeConverter {
   CaptureInfo getLoweredLocalCaptures(SILDeclRef fn);
   bool hasLoweredLocalCaptures(SILDeclRef fn);
 
+#ifndef NDEBUG
+  /// If \c false, \c childDC is in a context it cannot capture variables from,
+  /// so it is expected that Sema may not have computed its \c CaptureInfo.
+  ///
+  /// This call exists for use in assertions; do not use it to skip capture
+  /// processing.
+  static bool canCaptureFromParent(DeclContext *childDC) {
+    // This call was added because Sema leaves the captures of functions that
+    // cannot capture anything uncomputed.
+    // TODO: Make Sema set them to CaptureInfo::empty() instead.
+
+    if (childDC)
+      if (auto decl = childDC->getAsDecl())
+         return decl->getDeclContext()->isLocalContext();
+    return true;
+  }
+#endif
+
   enum class ABIDifference : uint8_t {
     // No ABI differences, function can be trivially bitcast to result type.
     Trivial,

lib/SIL/TypeLowering.cpp

@@ -24,9 +24,11 @@
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"
+#include "swift/AST/PrettyStackTrace.h"
 #include "swift/AST/PropertyWrappers.h"
 #include "swift/AST/Types.h"
 #include "swift/ClangImporter/ClangModule.h"
+#include "swift/SIL/PrettyStackTrace.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILModule.h"
@@ -2111,6 +2113,9 @@ TypeConverter::hasLoweredLocalCaptures(SILDeclRef fn) {
 
 CaptureInfo
 TypeConverter::getLoweredLocalCaptures(SILDeclRef fn) {
+  PrettyStackTraceSILLocation stack("getting lowered local captures",
+                                    fn.getAsRegularLocation(), Context);
+
   fn.isForeign = 0;
   fn.isCurried = 0;
   fn.isDirectReference = 0;
@@ -2132,11 +2137,14 @@ TypeConverter::getLoweredLocalCaptures(SILDeclRef fn) {
   DynamicSelfType *capturesDynamicSelf = nullptr;
   OpaqueValueExpr *capturesOpaqueValue = nullptr;
 
-  std::function<void (const CaptureInfo &captureInfo)> collectCaptures;
+  std::function<void (const CaptureInfo &captureInfo, DeclContext *dc)> collectCaptures;
   std::function<void (AnyFunctionRef)> collectFunctionCaptures;
   std::function<void (SILDeclRef)> collectConstantCaptures;
 
-  collectCaptures = [&](const CaptureInfo &captureInfo) {
+  collectCaptures = [&](const CaptureInfo &captureInfo, DeclContext *dc) {
+    assert(captureInfo.hasBeenComputed() ||
+           !TypeConverter::canCaptureFromParent(dc));
+
     if (captureInfo.hasGenericParamCaptures())
       capturesGenericParams = true;
     if (captureInfo.hasDynamicSelfCapture())
@@ -2263,7 +2271,9 @@ TypeConverter::getLoweredLocalCaptures(SILDeclRef fn) {
     if (!visitedFunctions.insert(curFn).second)
       return;
 
-    collectCaptures(curFn.getCaptureInfo());
+    PrettyStackTraceAnyFunctionRef("lowering local captures", curFn);
+    auto dc = curFn.getAsDeclContext();
+    collectCaptures(curFn.getCaptureInfo(), dc);
 
     // A function's captures also include its default arguments, because
     // when we reference a function we don't track which default arguments
@@ -2274,17 +2284,22 @@ TypeConverter::getLoweredLocalCaptures(SILDeclRef fn) {
     if (auto *AFD = curFn.getAbstractFunctionDecl()) {
       for (auto *P : *AFD->getParameters()) {
         if (P->getDefaultValue())
-          collectCaptures(P->getDefaultArgumentCaptureInfo());
+          collectCaptures(P->getDefaultArgumentCaptureInfo(), dc);
       }
     }
   };
 
   collectConstantCaptures = [&](SILDeclRef curFn) {
     if (curFn.isDefaultArgGenerator()) {
+      PrettyStackTraceSILLocation stack("lowering local captures",
+                                        fn.getAsRegularLocation(), Context);
+      
       if (auto *afd = dyn_cast<AbstractFunctionDecl>(curFn.getDecl())) {
         auto *param = getParameterAt(afd, curFn.defaultArgIndex);
-        if (param->getDefaultValue())
-          collectCaptures(param->getDefaultArgumentCaptureInfo());
+        if (param->getDefaultValue()) {
+          auto dc = afd->getInnermostDeclContext();
+          collectCaptures(param->getDefaultArgumentCaptureInfo(), dc);
+        }
         return;
       }
 

lib/SILGen/SILGenFunction.cpp

@@ -706,6 +706,14 @@ void SILGenFunction::emitGeneratorFunction(SILDeclRef function, Expr *value,
   CaptureInfo captureInfo;
   if (function.getAnyFunctionRef())
     captureInfo = SGM.M.Types.getLoweredLocalCaptures(function);
+  else {
+    // The expressions for these cannot capture.
+    assert(function.kind == SILDeclRef::Kind::StoredPropertyInitializer ||
+           function.kind == SILDeclRef::Kind::PropertyWrapperBackingInitializer ||
+           (function.getDecl() && !function.getDecl()->getDeclContext()->isLocalContext()));
+    captureInfo = CaptureInfo::empty();
+  }
+
   auto interfaceType = value->getType()->mapTypeOutOfContext();
   emitProlog(captureInfo, params, /*selfParam=*/nullptr,
              dc, interfaceType, /*throws=*/false, SourceLoc());

lib/SILGen/SILGenProlog.cpp

@@ -445,6 +445,9 @@ void SILGenFunction::emitProlog(const CaptureInfo &captureInfo,
 
   // Emit the capture argument variables. These are placed last because they
   // become the first curry level of the SIL function.
+  assert((captureInfo.hasBeenComputed() ||
+          !TypeConverter::canCaptureFromParent(DC)) &&
+         "can't emit prolog of function with uncomputed captures");
   for (auto capture : captureInfo.getCaptures()) {
     if (capture.isDynamicSelfMetadata()) {
       auto selfMetatype = MetatypeType::get(