Merge pull request #70635 from DougGregor/async-sequence-typed-throws

Adopt typed throws in AsyncIteratorProtocol and AsyncSequence

Author: DougGregor

include/swift/AST/ASTContext.h

@@ -650,6 +650,9 @@ class ASTContext final {
   /// Get AsyncIteratorProtocol.next().
   FuncDecl *getAsyncIteratorNext() const;
 
+  /// Get AsyncIteratorProtocol.next(actor).
+  FuncDecl *getAsyncIteratorNextIsolated() const;
+
   /// Check whether the standard library provides all the correct
   /// intrinsic support for Optional<T>.
   ///

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)

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;
   }

include/swift/SILOptimizer/Analysis/RegionAnalysis.h

@@ -299,7 +299,11 @@ class RegionAnalysisValueMap {
   /// This only includes function arguments.
   std::vector<TrackableValueID> neverTransferredValueIDs;
 
+  SILFunction *fn;
+
 public:
+  RegionAnalysisValueMap(SILFunction *fn) : fn(fn) { }
+
   /// Returns the value for this instruction if it isn't a fake "represenative
   /// value" to inject actor isolatedness. Asserts in such a case.
   SILValue getRepresentative(Element trackableValueID) const;

lib/AST/ASTContext.cpp

@@ -287,6 +287,10 @@ struct ASTContext::Implementation {
   /// The declaration of 'AsyncIteratorProtocol.next()'.
   FuncDecl *AsyncIteratorNext = nullptr;
 
+  /// The declaration of 'AsyncIteratorProtocol.next(_:)' that takes
+  /// an actor isolation.
+  FuncDecl *AsyncIteratorNextIsolated = nullptr;
+
   /// The declaration of Swift.Optional<T>.Some.
   EnumElementDecl *OptionalSomeDecl = nullptr;
 
@@ -948,21 +952,48 @@ FuncDecl *ASTContext::getIteratorNext() const {
   return nullptr;
 }
 
+static std::pair<FuncDecl *, FuncDecl *>
+getAsyncIteratorNextRequirements(const ASTContext &ctx) {
+  auto proto = ctx.getProtocol(KnownProtocolKind::AsyncIteratorProtocol);
+  if (!proto)
+    return { nullptr, nullptr };
+
+  FuncDecl *next = nullptr;
+  FuncDecl *nextThrowing = nullptr;
+  for (auto result : proto->lookupDirect(ctx.Id_next)) {
+    if (result->getDeclContext() != proto)
+      continue;
+
+    if (auto func = dyn_cast<FuncDecl>(result)) {
+      switch (func->getParameters()->size()) {
+      case 0: next = func; break;
+      case 1: nextThrowing = func; break;
+      default: break;
+      }
+    }
+  }
+
+  return { next, nextThrowing };
+}
+
 FuncDecl *ASTContext::getAsyncIteratorNext() const {
   if (getImpl().AsyncIteratorNext) {
     return getImpl().AsyncIteratorNext;
   }
 
-  auto proto = getProtocol(KnownProtocolKind::AsyncIteratorProtocol);
-  if (!proto)
-    return nullptr;
+  auto next = getAsyncIteratorNextRequirements(*this).first;
+  getImpl().AsyncIteratorNext = next;
+  return next;
+}
 
-  if (auto *func = lookupRequirement(proto, Id_next)) {
-    getImpl().AsyncIteratorNext = func;
-    return func;
+FuncDecl *ASTContext::getAsyncIteratorNextIsolated() const {
+  if (getImpl().AsyncIteratorNextIsolated) {
+    return getImpl().AsyncIteratorNextIsolated;
   }
 
-  return nullptr;
+  auto nextThrowing = getAsyncIteratorNextRequirements(*this).second;
+  getImpl().AsyncIteratorNextIsolated = nextThrowing;
+  return nextThrowing;
 }
 
 namespace {

lib/AST/Availability.cpp

@@ -819,6 +819,7 @@ ASTContext::getSwift5PlusAvailability(llvm::VersionTuple swiftVersion) {
     case 7: return getSwift57Availability();
     case 8: return getSwift58Availability();
     case 9: return getSwift59Availability();
+    case 11: return getSwift511Availability();
     default: break;
     }
   }

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/IRGen/MetadataRequest.cpp

@@ -1641,7 +1641,7 @@ static MetadataResponse emitFunctionTypeMetadataRef(IRGenFunction &IGF,
 
   default:
     assert((!params.empty() || type->isDifferentiable() ||
-            type->getGlobalActor()) &&
+            type->getGlobalActor() || type->getThrownError()) &&
            "0 parameter case should be specialized unless it is a "
            "differentiable function or has a global actor");
 

lib/SILOptimizer/Analysis/RegionAnalysis.cpp

@@ -2802,8 +2802,9 @@ static bool canComputeRegionsForFunction(SILFunction *fn) {
 
 RegionAnalysisFunctionInfo::RegionAnalysisFunctionInfo(
     SILFunction *fn, PostOrderFunctionInfo *pofi)
-    : allocator(), fn(fn), translator(), ptrSetFactory(allocator),
-      blockStates(), pofi(pofi), solved(false), supportedFunction(true) {
+    : allocator(), fn(fn), valueMap(fn), translator(),
+      ptrSetFactory(allocator), blockStates(), pofi(pofi), solved(false),
+      supportedFunction(true) {
   // Before we do anything, make sure that we support processing this function.
   //
   // NOTE: See documentation on supportedFunction for criteria.
@@ -3005,7 +3006,7 @@ TrackableValue RegionAnalysisValueMap::getTrackableValue(
   }
 
   // Otherwise refer to the oracle.
-  if (!isNonSendableType(value->getType(), value->getFunction()))
+  if (!isNonSendableType(value->getType(), fn))
     iter.first->getSecond().addFlag(TrackableValueFlag::isSendable);
 
   // Check if our base is a ref_element_addr from an actor. In such a case,