Rely on the next/nextElement call in an async for..each for throws effects

Our decision procedure for what type of error is thrown during
iteration of an async sequence was effectively duplicated between the
checking for the next/nextElement call (which is synthesized) and
separate logic for the async for..in loop. The latter is strictly
redundant, so switch to relying only on the former.

This is staging for customizing the next/nextElement call further.

Author: DougGregor

lib/Sema/TypeCheckEffects.cpp

@@ -1468,13 +1468,11 @@ class ApplyClassifier {
         ConditionalEffectKind::Always,
         PotentialEffectReason::forApply());
 
-    // Use the conformance to AsyncSequence to determine whether (and what)
-    // is thrown.
-    auto conformance = stmt->getSequenceConformance();
-    Type sequenceType = stmt->getSequenceType();
-    result.merge(
-        classifyConformance(
-          sequenceType, conformance, EffectKind::Throws));
+    if (!stmt->getNextCall())
+      return Classification::forInvalidCode();
+
+    // Merge the thrown result from the next/nextElement call.
+    result.merge(classifyExpr(stmt->getNextCall(), EffectKind::Throws));
 
     return result;
   }
@@ -3501,11 +3499,9 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
       if (throwsKind != ConditionalEffectKind::None)
         Flags.set(ContextFlags::HasAnyThrowSite);
 
-      if (!CurContext.handlesThrows(throwsKind))
-        CurContext.diagnoseUnhandledThrowStmt(Ctx.Diags, S);
-
-      // Note: we don't need to check the thrown error type specifically,
-      // because we will also be checking the nextElement call.
+      // Note: we don't need to check whether the throw error is handled,
+      // because we will also be checking the generated next/nextElement
+      // call.
     }
 
     return ShouldRecurse;

test/Concurrency/async_sequence_syntax.swift

@@ -15,8 +15,7 @@ func missingAsync<T : AsyncSequence>(_ seq: T) throws {
 @available(SwiftStdlib 5.1, *)
 func missingThrows<T : AsyncSequence>(_ seq: T) async {
   for try await _ in seq { } 
-  // expected-error@-1 {{error is not handled because the enclosing function is not declared 'throws'}}
-  // expected-error@-2 {{errors thrown from here are not handled}}
+  // expected-error@-1 {{errors thrown from here are not handled}}
 }
 
 @available(SwiftStdlib 5.1, *)
@@ -37,7 +36,6 @@ func missingTryInBlock<T : AsyncSequence>(_ seq: T) {
     for await _ in seq { } 
     // expected-error@-1{{call can throw, but the error is not handled}}
     // expected-error@-2{{errors thrown from here are not handled}}
-    // expected-error@-3{{error is not handled because the enclosing function is not declared 'throws'}}
   }
 }