AsyncSequence and protocol conformance rethrows (swiftlang#35224)

* Initial draft of async sequences

* Adjust AsyncSequence associated type requirements

* Add a draft implementation of AsyncSequence and associated functionality

* Correct merge damage and rename from GeneratorProtocol to AsyncIteratorProtocol

* Add AsyncSequence types to the cmake lists

* Add cancellation support

* [DRAFT] Implementation of protocol conformance rethrowing

* Account for ASTVerifier passes to ensure throwing and by conformance rethrowing verifies appropriately

* Remove commented out code

* OtherConstructorDeclRefExpr can also be a source of a rethrowing kind function

* Re-order the checkApply logic to account for existing throwing calculations better

* Extract rethrowing calculation into smaller functions

* Allow for closures and protocol conformances to contribute to throwing

* Add unit tests for conformance based rethrowing

* Restrict rethrowing requirements to only protocols marked with @rethrows

* Correct logic for gating of `@rethrows` and adjust the determinates to be based upon throws and not rethrows spelling

* Attempt to unify the async sequence features together

* Reorder try await to latest syntax

* revert back to the inout diagnosis

* House mutations in local scope

* Revert "House mutations in local scope"

This reverts commit d91f1b25b59fff8e4be107c808895ff3f293b394.

* Adjust for inout diagnostics and fall back to original mutation strategy

* Convert async flag to source locations and add initial try support to for await in syntax

* Fix case typo of MinMax.swift

* Adjust rethrowing tests to account for changes associated with @rethrows

* Allow parsing and diagnostics associated with try applied to for await in syntax

* Correct the code-completion for @rethrows

* Additional corrections for the code-completion for @rethrows this time for the last in the list

* Handle throwing cases of iteration of async sequences

* restore building XCTest

* First wave of feedback fixes

* Rework constraints checking for async sequence for-try-await-in checking

* Allow testing of for-await-in parsing and silgen testing and add unit tests for both

* Remove async sequence operators for now

* Back out cancellation of AsyncIteratorProtocols

* Restructure protocol conformance throws checking and cache results

* remove some stray whitespaces

* Correct some merge damage

* Ensure the throwing determinate for applying for-await-in always has a valid value and adjust the for-await-in silgen test to reflect the cancel changes

* Squelch the python linter for line length

Author: phausler

include/swift/AST/ASTContext.h

@@ -522,6 +522,9 @@ class ASTContext final {
   /// Get Sequence.makeIterator().
   FuncDecl *getSequenceMakeIterator() const;
 
+  /// Get AsyncSequence.makeAsyncIterator().
+  FuncDecl *getAsyncSequenceMakeAsyncIterator() const;
+
   /// Check whether the standard library provides all the correct
   /// intrinsic support for Optional<T>.
   ///

include/swift/AST/ASTTypeIDZone.def

@@ -31,6 +31,8 @@ SWIFT_TYPEID(PropertyWrapperTypeInfo)
 SWIFT_TYPEID(Requirement)
 SWIFT_TYPEID(ResilienceExpansion)
 SWIFT_TYPEID(FragileFunctionKind)
+SWIFT_TYPEID(FunctionRethrowingKind)
+SWIFT_TYPEID(ProtocolRethrowsRequirementList)
 SWIFT_TYPEID(TangentPropertyInfo)
 SWIFT_TYPEID(SymbolSourceMap)
 SWIFT_TYPEID(Type)

include/swift/AST/ASTTypeIDs.h

@@ -64,6 +64,8 @@ class ProtocolDecl;
 class Requirement;
 enum class ResilienceExpansion : unsigned;
 struct FragileFunctionKind;
+enum class FunctionRethrowingKind : uint8_t;
+class ProtocolRethrowsRequirementList;
 class SourceFile;
 class SymbolSourceMap;
 struct TangentPropertyInfo;

include/swift/AST/Attr.def

@@ -359,6 +359,10 @@ SIMPLE_DECL_ATTR(rethrows, Rethrows,
   RejectByParser |
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   57)
+SIMPLE_DECL_ATTR(rethrows, AtRethrows,
+  OnProtocol |
+  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
+  58)
 DECL_ATTR(_swift_native_objc_runtime_base, SwiftNativeObjCRuntimeBase,
   OnClass |
   UserInaccessible |

include/swift/AST/Decl.h

@@ -3879,6 +3879,66 @@ enum class KnownDerivableProtocolKind : uint8_t {
   Actor,
 };
 
+class ProtocolRethrowsRequirementList {
+public:
+  typedef std::pair<Type, ValueDecl *> Entry;
+
+private:
+  ArrayRef<Entry> entries;
+
+public:
+  ProtocolRethrowsRequirementList(ArrayRef<Entry> entries) : entries(entries) {}
+  ProtocolRethrowsRequirementList() : entries() {}
+
+  typedef const Entry *const_iterator;
+  typedef const_iterator iterator;
+
+  const_iterator begin() const { return entries.begin(); }
+  const_iterator end() const { return entries.end(); }
+
+  size_t size() const { return entries.size(); }
+
+  void print(raw_ostream &OS) const;
+
+  SWIFT_DEBUG_DUMP;
+
+  friend bool operator==(const ProtocolRethrowsRequirementList &lhs,
+                         const ProtocolRethrowsRequirementList &rhs) {
+    if (lhs.size() != rhs.size()) {
+      return false;
+    }
+    auto lhsIter = lhs.begin();
+    auto rhsIter = rhs.begin();
+    while (lhsIter != lhs.end() && rhsIter != rhs.end()) {
+      if (lhsIter->first->isEqual(rhsIter->first)) {
+        return false;
+      }
+      if (lhsIter->second != rhsIter->second) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  friend bool operator!=(const ProtocolRethrowsRequirementList &lhs,
+                         const ProtocolRethrowsRequirementList &rhs) {
+    return !(lhs == rhs);
+  }
+
+  friend llvm::hash_code hash_value(
+    const ProtocolRethrowsRequirementList &list) {
+    return llvm::hash_combine(list.size()); // it is good enought for
+    // llvm::hash_code hash;
+    // for (auto entry : list) {
+    //   hash = llvm::hash_combine(hash, entry.first->getCanonicalType());
+    //   hash = llvm::hash_combine(hash, entry.second);
+    // }
+    // return hash;
+  }
+};
+
+void simple_display(raw_ostream &out, const ProtocolRethrowsRequirementList reqs);
+
 /// ProtocolDecl - A declaration of a protocol, for example:
 ///
 ///   protocol Drawable {
@@ -4060,6 +4120,9 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// contain 'Self' in 'parameter' or 'other' position.
   bool existentialTypeSupported() const;
 
+  ProtocolRethrowsRequirementList getRethrowingRequirements() const;
+  bool isRethrowingProtocol() const;
+
 private:
   void computeKnownProtocolKind() const;
 
@@ -5469,6 +5532,23 @@ class ImportAsMemberStatus {
   }
 };
 
+enum class FunctionRethrowingKind : uint8_t {
+  /// The function is not throwing
+  None,
+
+  /// The function rethrows by closure
+  ByClosure, 
+
+  /// The function rethrows by conformance
+  ByConformance, 
+
+  /// The function throws
+  Throws, 
+
+  /// The function throwing determinate is invalid
+  Invalid
+};
+
 /// Base class for function-like declarations.
 class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   friend class NeedsNewVTableEntryRequest;
@@ -5671,6 +5751,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Returns true if the function body throws.
   bool hasThrows() const { return Bits.AbstractFunctionDecl.Throws; }
 
+  FunctionRethrowingKind getRethrowingKind() const;
+
   // FIXME: Hack that provides names with keyword arguments for accessors.
   DeclName getEffectiveFullName() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -2983,6 +2983,8 @@ ERROR(override_rethrows_with_non_rethrows,none,
       "be 'rethrows'", (bool))
 ERROR(rethrows_without_throwing_parameter,none,
       "'rethrows' function must take a throwing function argument", ())
+ERROR(rethrows_attr_on_non_protocol,none,
+      "@rethrows may only be used on 'protocol' declarations", ())
 
 ERROR(autoclosure_function_type,none,
       "@autoclosure attribute only applies to function types",
@@ -4059,6 +4061,8 @@ NOTE(because_rethrows_argument_throws,none,
 NOTE(because_rethrows_default_argument_throws,none,
      "call is to 'rethrows' function, but a defaulted argument function"
      " can throw", ())
+NOTE(because_rethrows_default_conformance_throws,none,
+     "call is to 'rethrows' function, but a conformance has a throwing witness", ())
 
 ERROR(throwing_call_in_nonthrowing_autoclosure,none,
       "call can throw, but it is executed in a non-throwing "

include/swift/AST/KnownIdentifiers.def

@@ -93,7 +93,9 @@ IDENTIFIER(KeyedEncodingContainer)
 IDENTIFIER(keyedBy)
 IDENTIFIER(keyPath)
 IDENTIFIER(makeIterator)
+IDENTIFIER(makeAsyncIterator)
 IDENTIFIER(Iterator)
+IDENTIFIER(AsyncIterator)
 IDENTIFIER(load)
 IDENTIFIER(main)
 IDENTIFIER_WITH_NAME(MainEntryPoint, "$main")

include/swift/AST/KnownProtocols.def

@@ -88,6 +88,9 @@ PROTOCOL(StringInterpolationProtocol)
 PROTOCOL(AdditiveArithmetic)
 PROTOCOL(Differentiable)
 
+PROTOCOL(AsyncSequence)
+PROTOCOL(AsyncIteratorProtocol)
+
 PROTOCOL(FloatingPoint)
 
 EXPRESSIBLE_BY_LITERAL_PROTOCOL(ExpressibleByArrayLiteral, "Array", false)

include/swift/AST/ProtocolConformanceRef.h

@@ -170,8 +170,13 @@ class ProtocolConformanceRef {
   /// Get any additional requirements that are required for this conformance to
   /// be satisfied.
   ArrayRef<Requirement> getConditionalRequirements() const;
+
+  bool classifyAsThrows() const;
 };
 
+void simple_display(llvm::raw_ostream &out, ProtocolConformanceRef conformanceRef);
+SourceLoc extractNearestSourceLoc(const ProtocolConformanceRef conformanceRef);
+
 } // end namespace swift
 
 #endif // LLVM_SWIFT_AST_PROTOCOLCONFORMANCEREF_H

include/swift/AST/Stmt.h

@@ -726,6 +726,8 @@ class RepeatWhileStmt : public LabeledStmt {
 /// \endcode
 class ForEachStmt : public LabeledStmt {
   SourceLoc ForLoc;
+  SourceLoc TryLoc;
+  SourceLoc AwaitLoc;
   Pattern *Pat;
   SourceLoc InLoc;
   Expr *Sequence;
@@ -741,12 +743,12 @@ class ForEachStmt : public LabeledStmt {
   Expr *convertElementExpr = nullptr;
 
 public:
-  ForEachStmt(LabeledStmtInfo LabelInfo, SourceLoc ForLoc, Pattern *Pat,
-              SourceLoc InLoc, Expr *Sequence, SourceLoc WhereLoc,
+  ForEachStmt(LabeledStmtInfo LabelInfo, SourceLoc ForLoc, SourceLoc TryLoc, SourceLoc AwaitLoc, 
+              Pattern *Pat, SourceLoc InLoc, Expr *Sequence, SourceLoc WhereLoc,
               Expr *WhereExpr, BraceStmt *Body, Optional<bool> implicit = None)
     : LabeledStmt(StmtKind::ForEach, getDefaultImplicitFlag(implicit, ForLoc),
                   LabelInfo),
-      ForLoc(ForLoc), Pat(nullptr), InLoc(InLoc), Sequence(Sequence),
+      ForLoc(ForLoc), TryLoc(TryLoc), AwaitLoc(AwaitLoc), Pat(nullptr), InLoc(InLoc), Sequence(Sequence),
       WhereLoc(WhereLoc), WhereExpr(WhereExpr), Body(Body) {
     setPattern(Pat);
   }
@@ -778,6 +780,9 @@ class ForEachStmt : public LabeledStmt {
 
   /// getWhereLoc - Retrieve the location of the 'where' keyword.
   SourceLoc getWhereLoc() const { return WhereLoc; }
+
+  SourceLoc getAwaitLoc() const { return AwaitLoc; }
+  SourceLoc getTryLoc() const { return TryLoc; }
 
   /// getPattern - Retrieve the pattern describing the iteration variables.
   /// These variables will only be visible within the body of the loop.