Sema: Remove incorrect and incomplete forward capture analysis

Sema does not have enough information to diagnose these problems correctly.

Also, there was an unimplemented case in the analysis; if a closure did not
yet have computed captures, we'd add it to the ForwardCapturedFuncs list,
but nothing ever looked at that list.

Author: slavapestov

Diff for: include/swift/AST/DiagnosticsSema.def

@@ -3016,14 +3016,6 @@ ERROR(method_call_in_closure_without_explicit_self,none,
 ERROR(implicit_use_of_self_in_closure,none,
       "implicit use of 'self' in closure; use 'self.' to make"
       " capture semantics explicit", ())
-ERROR(capture_before_declaration,none,
-      "cannot capture %0 before it is declared", (Identifier))
-ERROR(transitive_capture_before_declaration,none,
-      "cannot capture %0, which would use %1 before it is declared",
-      (Identifier, Identifier))
-NOTE(transitive_capture_through_here,none,
-     "%0, declared here, captures %1",
-     (Identifier, Identifier))
 
 WARNING(recursive_accessor_reference,none,
         "attempting to %select{access|modify}1 %0 within its own "

Diff for: lib/Sema/TypeCheckCaptures.cpp

@@ -300,74 +300,6 @@ class FindCapturedVars : public ASTWalker {
     if (!isa<VarDecl>(D) && !DC->isLocalContext())
       return { false, DRE };
 
-    // Can only capture a variable that is declared before the capturing
-    // entity.
-    llvm::DenseSet<ValueDecl *> checkedCaptures;
-    llvm::SmallVector<FuncDecl *, 2> capturePath;
-
-    std::function<bool (ValueDecl *)>
-    validateForwardCapture = [&](ValueDecl *capturedDecl) -> bool {
-      if (!checkedCaptures.insert(capturedDecl).second)
-        return true;
-
-      // Captures at nonlocal scope are order-invariant.
-      if (!capturedDecl->getDeclContext()->isLocalContext())
-        return true;
-
-      // Assume implicit decl captures are OK.
-      if (!CaptureLoc.isValid() || !capturedDecl->getLoc().isValid())
-        return true;
-
-      // Check the order of the declarations.
-      if (!TC.Context.SourceMgr.isBeforeInBuffer(CaptureLoc,
-                                                 capturedDecl->getLoc()))
-        return true;
-
-      // Forward captures of functions are OK, if the function doesn't
-      // transitively capture variables ahead of the original function.
-      if (auto func = dyn_cast<FuncDecl>(capturedDecl)) {
-        if (!func->getCaptureInfo().hasBeenComputed()) {
-          // Check later.
-          TC.ForwardCapturedFuncs[func].push_back(AFR);
-          return true;
-        }
-        // Recursively check the transitive captures.
-        capturePath.push_back(func);
-        SWIFT_DEFER { capturePath.pop_back(); };
-        for (auto capture : func->getCaptureInfo().getCaptures())
-          if (!validateForwardCapture(capture.getDecl()))
-            return false;
-        return true;
-      }
-
-      // Diagnose the improper forward capture.
-      if (Diagnosed.insert(capturedDecl).second) {
-        if (capturedDecl == DRE->getDecl()) {
-          TC.diagnose(DRE->getLoc(), diag::capture_before_declaration,
-                      capturedDecl->getBaseName().getIdentifier());
-        } else {
-          TC.diagnose(DRE->getLoc(),
-                      diag::transitive_capture_before_declaration,
-                      DRE->getDecl()->getBaseName().getIdentifier(),
-                      capturedDecl->getBaseName().getIdentifier());
-          ValueDecl *prevDecl = capturedDecl;
-          for (auto path : reversed(capturePath)) {
-            TC.diagnose(path->getLoc(),
-                        diag::transitive_capture_through_here,
-                        path->getName(),
-                        prevDecl->getBaseName().getIdentifier());
-            prevDecl = path;
-          }
-        }
-        TC.diagnose(capturedDecl, diag::decl_declared_here,
-                    capturedDecl->getFullName());
-      }
-      return false;
-    };
-
-    if (!validateForwardCapture(DRE->getDecl()))
-      return { false, DRE };
-
     // We're going to capture this, compute flags for the capture.
     unsigned Flags = 0;
 

Diff for: lib/Sema/TypeChecker.h

@@ -569,25 +569,6 @@ class TypeChecker final : public LazyResolver {
   /// will need to compute captures for.
   std::vector<AbstractClosureExpr *> ClosuresWithUncomputedCaptures;
 
-  /// Local functions that have been captured before their definitions.
-  ///
-  /// We need this to guard against functions that would transitively capture
-  /// variables before their definition, e.g.:
-  ///
-  /// func outer() {
-  ///   func first() {
-  ///     second()
-  ///   }
-  ///   second()
-  ///   var x
-  ///   func second() {
-  ///     use(x)
-  ///   }
-  /// }
-
-  llvm::SmallDenseMap<AnyFunctionRef, SmallVector<AnyFunctionRef, 4>, 4>
-    ForwardCapturedFuncs;
-
   /// A set of local functions from which C function pointers are derived.
   ///
   /// This is used to diagnose the use of local functions with captured context