Switch async for-each loop over to _nextElement and drop @rethrows.

This couples together several changes to move entirely from
`@rethrows` over to typed throws:

* Use the `Failure` type to determine whether an async for-each loop
will throw, rather than depending on rethrows checking

* Introduce a special carve-out for `rethrows` functions that have a
generic requirement on an `AsyncSequence` or `AsyncIteratorProtocol`,
which uses that requirement's `Failure` type as potentially being part
of the thrown error type. This allows existing generic functions like
the following to continue to work:

    func f<S: AsyncSequence>(_: S) rethrows

* Switch SIL generation for the async for-each loop from the prior
`next()` over to the typed-throws version `_nextElement`.

* Remove `@rethrows` from `AsyncSequence` and `AsyncIteratorProtocol`
entirely. We are now fully dependent on typed throws.

Author: DougGregor

include/swift/AST/Effects.h

@@ -87,6 +87,11 @@ enum class PolymorphicEffectKind : uint8_t {
   /// This is the conformance-based 'rethrows' /'reasync' case.
   ByConformance,
 
+  /// The function is only permitted to be `rethrows` because it depends
+  /// on a conformance to `AsyncSequence` or `AsyncIteratorProtocol`,
+  /// which historically were "@rethrows" protocols.
+  AsyncSequenceRethrows,
+
   /// The function has this effect unconditionally.
   ///
   /// This is a plain old 'throws' / 'async' function.

include/swift/AST/KnownIdentifiers.def

@@ -90,6 +90,7 @@ IDENTIFIER(enqueue)
 IDENTIFIER(erasing)
 IDENTIFIER(error)
 IDENTIFIER(errorDomain)
+IDENTIFIER(Failure)
 IDENTIFIER(first)
 IDENTIFIER(forKeyedSubscript)
 IDENTIFIER(Foundation)
@@ -122,6 +123,7 @@ IDENTIFIER(load)
 IDENTIFIER(main)
 IDENTIFIER_WITH_NAME(MainEntryPoint, "$main")
 IDENTIFIER(next)
+IDENTIFIER_(nextElement)
 IDENTIFIER_(nsErrorDomain)
 IDENTIFIER(objectAtIndexedSubscript)
 IDENTIFIER(objectForKeyedSubscript)

include/swift/AST/Stmt.h

@@ -971,6 +971,7 @@ class ForEachStmt : public LabeledStmt {
 
   // Set by Sema:
   ProtocolConformanceRef sequenceConformance = ProtocolConformanceRef();
+  Type sequenceType;
   PatternBindingDecl *iteratorVar = nullptr;
   Expr *nextCall = nullptr;
   OpaqueValueExpr *elementExpr = nullptr;
@@ -1001,9 +1002,12 @@ class ForEachStmt : public LabeledStmt {
   void setConvertElementExpr(Expr *expr) { convertElementExpr = expr; }
   Expr *getConvertElementExpr() const { return convertElementExpr; }
 
-  void setSequenceConformance(ProtocolConformanceRef conformance) {
+  void setSequenceConformance(Type type,
+                              ProtocolConformanceRef conformance) {
+    sequenceType = type;
     sequenceConformance = conformance;
   }
+  Type getSequenceType() const { return sequenceType; }
   ProtocolConformanceRef getSequenceConformance() const {
     return sequenceConformance;
   }

lib/AST/ASTContext.cpp

@@ -957,6 +957,12 @@ FuncDecl *ASTContext::getAsyncIteratorNext() const {
   if (!proto)
     return nullptr;
 
+  if (auto *func = lookupRequirement(
+          proto, getIdentifier("_nextElement"))) {
+    getImpl().AsyncIteratorNext = func;
+    return func;
+  }
+
   if (auto *func = lookupRequirement(proto, Id_next)) {
     getImpl().AsyncIteratorNext = func;
     return func;

lib/AST/Effects.cpp

@@ -114,6 +114,9 @@ void swift::simple_display(llvm::raw_ostream &out,
   case PolymorphicEffectKind::ByConformance:
     out << "by conformance";
     break;
+  case PolymorphicEffectKind::AsyncSequenceRethrows:
+    out << "by async sequence implicit @rethrows";
+    break;
   case PolymorphicEffectKind::Always:
     out << "always";
     break;

lib/Sema/AssociatedTypeInference.cpp

@@ -1914,7 +1914,7 @@ AssociatedTypeInference::computeFailureTypeWitness(
             auto proto = req.getProtocolDecl();
             if (proto->isSpecificProtocol(KnownProtocolKind::AsyncIteratorProtocol) ||
                 proto->isSpecificProtocol(KnownProtocolKind::AsyncSequence)) {
-              auto failureAssocType = proto->getAssociatedType(ctx.getIdentifier("Failure"));
+              auto failureAssocType = proto->getAssociatedType(ctx.Id_Failure);
               auto failureType = DependentMemberType::get(req.getFirstType(), failureAssocType);
               return AbstractTypeWitness(assocType, dc->mapTypeIntoContext(failureType));
             }

lib/Sema/CSApply.cpp

@@ -9194,7 +9194,7 @@ static llvm::Optional<SequenceIterationInfo> applySolutionToForEachStmt(
       type, sequenceProto);
   assert(!sequenceConformance.isInvalid() &&
          "Couldn't find sequence conformance");
-  stmt->setSequenceConformance(sequenceConformance);
+  stmt->setSequenceConformance(type, sequenceConformance);
 
   // Apply the solution to the filtering condition, if there is one.
   if (auto *whereExpr = stmt->getWhere()) {

lib/Sema/CSGen.cpp

@@ -4592,11 +4592,15 @@ generateForEachStmtConstraints(ConstraintSystem &cs, DeclContext *dc,
   // Now, result type of `.makeIterator()` is used to form a call to
   // `.next()`. `next()` is called on each iteration of the loop.
   {
+    FuncDecl *nextFn = isAsync ? ctx.getAsyncIteratorNext()
+                               : ctx.getIteratorNext();
+    Identifier nextId = nextFn ? nextFn->getName().getBaseIdentifier()
+                               : ctx.Id_next;
     auto *nextRef = UnresolvedDotExpr::createImplicit(
         ctx,
         new (ctx) DeclRefExpr(makeIteratorVar, DeclNameLoc(stmt->getForLoc()),
                               /*Implicit=*/true),
-        ctx.Id_next, /*labels=*/ArrayRef<Identifier>());
+        nextId, /*labels=*/ArrayRef<Identifier>());
     nextRef->setFunctionRefKind(FunctionRefKind::SingleApply);
 
     Expr *nextCall = CallExpr::createImplicitEmpty(ctx, nextRef);

lib/Sema/CSSimplify.cpp

@@ -10704,7 +10704,8 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
 
       // Handle `next` reference.
       if (getContextualTypePurpose(baseExpr) == CTP_ForEachSequence &&
-          isRefTo(memberRef, ctx.Id_next, /*labels=*/{})) {
+          (isRefTo(memberRef, ctx.Id_next, /*labels=*/{}) ||
+           isRefTo(memberRef, ctx.Id_nextElement, /*labels=*/{}))) {
         auto *iteratorProto = cast<ProtocolDecl>(
             getContextualType(baseExpr, /*forConstraint=*/false)
                 ->getAnyNominal());
@@ -10930,7 +10931,8 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
             if (auto *base = dyn_cast<DeclRefExpr>(UDE->getBase())) {
               if (auto var = dyn_cast_or_null<VarDecl>(base->getDecl())) {
                 if (var->getNameStr().contains("$generator") &&
-                    UDE->getName().getBaseIdentifier() == Context.Id_next)
+                    (UDE->getName().getBaseIdentifier() == Context.Id_next ||
+                     UDE->getName().getBaseIdentifier() == Context.Id_nextElement))
                   return success();
               }
             }

lib/Sema/MiscDiagnostics.cpp

@@ -6239,17 +6239,14 @@ llvm::Optional<Identifier> TypeChecker::omitNeedlessWords(VarDecl *var) {
 
 bool swift::diagnoseUnhandledThrowsInAsyncContext(DeclContext *dc,
                                                   ForEachStmt *forEach) {
-  if (!forEach->getAwaitLoc().isValid())
-    return false;
-
-  auto conformanceRef = forEach->getSequenceConformance();
-  if (conformanceRef.hasEffect(EffectKind::Throws) &&
-      forEach->getTryLoc().isInvalid()) {
-    auto &ctx = dc->getASTContext();
-    ctx.Diags
-        .diagnose(forEach->getAwaitLoc(), diag::throwing_call_unhandled, "call")
-        .fixItInsert(forEach->getAwaitLoc(), "try");
-    return true;
+  auto &ctx = dc->getASTContext();
+  if (auto thrownError = TypeChecker::canThrow(ctx, forEach)) {
+    if (forEach->getTryLoc().isInvalid()) {
+      ctx.Diags
+          .diagnose(forEach->getAwaitLoc(), diag::throwing_call_unhandled, "call")
+          .fixItInsert(forEach->getAwaitLoc(), "try");
+      return true;
+    }
   }
 
   return false;