Sema: Fix effects checking of 'for await' with a concrete conformance

AsyncSequence is only polymorphic over 'throws' effects, not 'async',
because it is @rethrows and not @reasync. So the logic here was wrong,
and it would incorrectly conclude that a 'for await' with a concrete
conformance did not require the outer function to be 'async'.

Fixes rdar://problem/75436909.

Author: slavapestov

lib/Sema/TypeCheckEffects.cpp

@@ -1173,12 +1173,7 @@ class ApplyClassifier {
 
     ShouldRecurse_t checkForEach(ForEachStmt *S) {
       if (S->getAwaitLoc().isValid()) {
-        auto classification = Self.classifyConformance(
-            S->getSequenceConformance(),
-            EffectKind::Async);
-        IsInvalid |= classification.isInvalid();
-        AsyncKind = std::max(AsyncKind,
-                             classification.getConditionalKind(EffectKind::Async));
+        AsyncKind = std::max(AsyncKind, ConditionalEffectKind::Always);
       }
 
       return ShouldRecurse;
@@ -2735,10 +2730,19 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
     if (!S->getAwaitLoc().isValid())
       return ShouldRecurse;
 
+    // A 'for await' is always async. There's no effect polymorphism
+    // via the conformance in a 'reasync' function body.
+    Flags.set(ContextFlags::HasAnyAsyncSite);
+
+    if (!CurContext.handlesAsync(ConditionalEffectKind::Always))
+      CurContext.diagnoseUnhandledAsyncSite(Ctx.Diags, S, None);
+
     ApplyClassifier classifier;
     classifier.RethrowsDC = RethrowsDC;
     classifier.ReasyncDC = ReasyncDC;
 
+    // A 'for try await' might be effect polymorphic via the conformance
+    // in a 'rethrows' function body.
     if (S->getTryLoc().isValid()) {
       auto classification = classifier.classifyConformance(
           S->getSequenceConformance(), EffectKind::Throws);
@@ -2751,16 +2755,6 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
         CurContext.diagnoseUnhandledThrowStmt(Ctx.Diags, S);
     }
 
-    auto classification = classifier.classifyConformance(
-        S->getSequenceConformance(), EffectKind::Async);
-    auto asyncKind = classification.getConditionalKind(EffectKind::Async);
-
-    if (asyncKind != ConditionalEffectKind::None)
-      Flags.set(ContextFlags::HasAnyAsyncSite);
-
-    if (!CurContext.handlesAsync(asyncKind))
-      CurContext.diagnoseUnhandledAsyncSite(Ctx.Diags, S, None);
-
     return ShouldRecurse;
   }
 };

test/Concurrency/async_sequence_syntax.swift

@@ -75,3 +75,10 @@ func forAwaitInsideDoCatch<Source: AsyncSequence>(_ source: Source) async {
     }
   } catch {} // no-warning
 }
+
+@available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+func forAwaitWithConcreteType(_ seq: ThrowingAsyncSequence) throws { // expected-note {{add 'async' to function 'forAwaitWithConcreteType' to make it asynchronous}}
+  for try await elt in seq { // expected-error {{'async' in a function that does not support concurrency}}
+    _ = elt
+  }
+}