Sema: Fix preservation of DiagnoseErrorOnTry flag

This fixes a regression from some over-eager logic introduced by my commit
5d6cf5c.

We need to be careful to preserve this flag only in cases where the
throwing-ness bubbles up from the nested ContextScope, namely AwaitExpr
and InterpolatedStringLiteralExpr.

Fixes <rdar://problem/72748150>.

Author: slavapestov

lib/Sema/TypeCheckEffects.cpp

@@ -1584,10 +1584,22 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
       OldMaxThrowingKind = std::max(OldMaxThrowingKind, Self.MaxThrowingKind);
     }
 
+    void preserveDiagnoseErrorOnTryFlag() {
+      // The "DiagnoseErrorOnTry" flag is a bit of mutable state
+      // in the Context itself, used to postpone diagnostic emission
+      // to a parent "try" expression. If something was diagnosed
+      // during this ContextScope, the flag may have been set, and
+      // we need to preseve its value when restoring the old Context.
+      bool DiagnoseErrorOnTry = Self.CurContext.shouldDiagnoseErrorOnTry();
+      OldContext.setDiagnoseErrorOnTry(DiagnoseErrorOnTry);
+    }
+
     void preserveCoverageFromAwaitOperand() {
       OldFlags.mergeFrom(ContextFlags::HasAnyAwait, Self.Flags);
       OldFlags.mergeFrom(ContextFlags::throwFlags(), Self.Flags);
       OldMaxThrowingKind = std::max(OldMaxThrowingKind, Self.MaxThrowingKind);
+
+      preserveDiagnoseErrorOnTryFlag();
     }
 
     void preserveCoverageFromTryOperand() {
@@ -1606,22 +1618,16 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
       OldFlags.mergeFrom(ContextFlags::HasAnyAsyncSite, Self.Flags);
       OldFlags.mergeFrom(ContextFlags::HasAnyAwait, Self.Flags);
       OldMaxThrowingKind = std::max(OldMaxThrowingKind, Self.MaxThrowingKind);
+
+      preserveDiagnoseErrorOnTryFlag();
     }
 
     bool wasTopLevelDebuggerFunction() const {
       return OldFlags.has(ContextFlags::IsTopLevelDebuggerFunction);
     }
 
     ~ContextScope() {
-      // The "DiagnoseErrorOnTry" flag is a bit of mutable state
-      // in the Context itself, used to postpone diagnostic emission
-      // to a parent "try" expression. If something was diagnosed
-      // during this ContextScope, the flag may have been set, and
-      // we need to preseve its value when restoring the old Context.
-      bool DiagnoseErrorOnTry = Self.CurContext.shouldDiagnoseErrorOnTry();
       Self.CurContext = OldContext;
-      Self.CurContext.setDiagnoseErrorOnTry(DiagnoseErrorOnTry);
-
       Self.RethrowsDC = OldRethrowsDC;
       Self.Flags = OldFlags;
       Self.MaxThrowingKind = OldMaxThrowingKind;

test/Concurrency/async_tasks.swift

@@ -53,7 +53,7 @@ func test_unsafeContinuations() async {
   }
 }
 
-func test_unsafeThrowingContinuations() async {
+func test_unsafeThrowingContinuations() async throws {
   let _: String = try await withUnsafeThrowingContinuation { continuation in
     continuation.resume(returning: "")
   }

test/stmt/errors.swift

@@ -263,4 +263,11 @@ func sr_13654_invalid_interpolation() {
 func sr_13654_valid_interpolation() throws {
   _ = try "\(sr_13654_func())"
   _ = "\(try sr_13654_func())"
+}
+
+// rdar://problem/72748150
+func takesClosure(_: (() -> ())) throws -> Int {}
+
+func passesClosure() {
+    _ = try takesClosure { } // expected-error {{errors thrown from here are not handled}}
 }

test/stmt/errors_async.swift

@@ -0,0 +1,14 @@
+// RUN: %target-swift-frontend -typecheck -verify %s -enable-experimental-concurrency
+
+// REQUIRES: concurrency
+
+enum MyError : Error {
+  case bad
+}
+
+func shouldThrow() async {
+  // expected-error@+1 {{errors thrown from here are not handled}}
+  let _: Int = try await withUnsafeThrowingContinuation { continuation in
+    continuation.resume(throwing: MyError.bad)
+  }
+}