[Effects handling] Eliminate Context::getHandled().

We don't want to expose the notion of "handles everything", because
that's a honeypot for messing up 'async' checking when making a context
change for error-handling, and vice versa. Instead, provide an API to
produce a derived context where all errors are handled, and use it for
(e.g.) try/try!/try? and exhaustive do-catches.

Author: DougGregor

lib/Sema/TypeCheckEffects.cpp

@@ -857,6 +857,10 @@ class Context {
   Kind TheKind;
   Optional<AnyFunctionRef> Function;
   bool HandlesErrors = false;
+
+  /// Whether error-handling queries should ignore the function context, e.g.,
+  /// for autoclosure and rethrows checks.
+  bool ErrorHandlingIgnoresFunction = false;
   bool IsNonExhaustiveCatch = false;
   bool DiagnoseErrorOnTry = false;
   InterpolatedStringLiteralExpr *InterpolatedString = nullptr;
@@ -876,6 +880,9 @@ class Context {
     if (!HandlesErrors)
       return false;
 
+    if (ErrorHandlingIgnoresFunction)
+      return false;
+
     if (!Function)
       return false;
 
@@ -891,17 +898,16 @@ class Context {
     if (!Function)
       return false;
 
+    if (ErrorHandlingIgnoresFunction)
+      return false;
+
     auto closure = Function->getAbstractClosureExpr();
     if (!closure)
       return false;
 
     return isa<AutoClosureExpr>(closure);
   }
 
-  static Context getHandled() {
-    return Context(/*handlesErrors=*/true, None);
-  }
-
   static Context forTopLevelCode(TopLevelCodeDecl *D) {
     // Top-level code implicitly handles errors and 'async' calls.
     return Context(/*handlesErrors=*/true, None);
@@ -976,6 +982,15 @@ class Context {
     return copy;
   }
 
+  /// Form a subcontext that handles all errors, e.g., for the body of a
+  /// do-catch with exhaustive catch clauses.
+  Context withHandlesErrors() const {
+    Context copy = *this;
+    copy.HandlesErrors = true;
+    copy.ErrorHandlingIgnoresFunction = true;
+    return copy;
+  }
+
   Kind getKind() const { return TheKind; }
 
   bool handlesNothing() const {
@@ -1416,8 +1431,8 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
   }
 
   ThrowingKind checkExhaustiveDoBody(DoCatchStmt *S) {
-    // This is a handled context.
-    ContextScope scope(*this, Context::getHandled());
+    // This is a context where errors are handled.
+    ContextScope scope(*this, CurContext.withHandlesErrors());
     assert(!Flags.has(ContextFlags::IsInTry) && "do/catch within try?");
     scope.resetCoverageForDoCatch();
 
@@ -1474,9 +1489,9 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
     if (doThrowingKind != ThrowingKind::Throws &&
         CurContext.isRethrows()) {
       // If this catch clause is reachable at all, it's because a function
-      // parameter throws. So let's temporarily set our context to Handled so
-      // the catch body is allowed to throw.
-      CurContext = Context::getHandled();
+      // parameter throws. So let's temporarily state that the body is allowed
+      // to throw.
+      CurContext = CurContext.withHandlesErrors();
     }
 
     // The catch body just happens in the enclosing context.
@@ -1661,7 +1676,7 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
 
   ShouldRecurse_t checkForceTry(ForceTryExpr *E) {
     // Walk the operand.  'try!' handles errors.
-    ContextScope scope(*this, Context::getHandled());
+    ContextScope scope(*this, CurContext.withHandlesErrors());
     scope.enterTry();
 
     E->getSubExpr()->walk(*this);
@@ -1675,7 +1690,7 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
 
   ShouldRecurse_t checkOptionalTry(OptionalTryExpr *E) {
     // Walk the operand.  'try?' handles errors.
-    ContextScope scope(*this, Context::getHandled());
+    ContextScope scope(*this, CurContext.withHandlesErrors());
     scope.enterTry();
 
     E->getSubExpr()->walk(*this);