Merge pull request #2581 from swiftwasm/maxd/main-merge

Resolve conflicts with the main branch

Author: MaxDesiatov

include/swift/ABI/Executor.h

@@ -118,7 +118,7 @@ using JobInvokeFunction =
 
 using TaskContinuationFunction =
   SWIFT_CC(swiftasync)
-  void (AsyncTask *, ExecutorRef, AsyncContext *);
+  void (AsyncTask *, ExecutorRef, SWIFT_ASYNC_CONTEXT AsyncContext *);
 
 template <class AsyncSignature>
 class AsyncFunctionPointer;

include/swift/ABI/MetadataValues.h

@@ -1172,6 +1172,9 @@ namespace SpecialPointerAuthDiscriminators {
   const uint16_t AsyncContextYield = 0xe207; // = 57863
   const uint16_t CancellationNotificationFunction = 0x1933; // = 6451
   const uint16_t EscalationNotificationFunction = 0x5be4; // = 23524
+
+  /// Swift async context parameter stored in the extended frame info.
+  const uint16_t SwiftAsyncContextExtendedFrameEntry = 0xc31a;
 }
 
 /// The number of arguments that will be passed directly to a generic

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/DiagnosticsParse.def

@@ -791,6 +791,8 @@ ERROR(protocol_method_argument_init,none,
       "default argument not permitted in a protocol method", ())
 ERROR(protocol_init_argument_init,none,
       "default argument not permitted in a protocol initializer", ())
+ERROR(protocol_subscript_argument_init,none,
+      "default argument not permitted in a protocol subscript", ())
 ERROR(tuple_type_multiple_labels,none,
       "tuple element cannot have two labels", ())
 

include/swift/AST/DiagnosticsSema.def

@@ -2454,8 +2454,10 @@ NOTE(overridden_near_match_here,none,
      "potential overridden %0 %1 here",
       (DescriptiveDeclKind, DeclName))
 ERROR(override_decl_extension,none,
-      "overriding %select{|non-@objc }0declarations "
-      "%select{in extensions|from extensions}0 is not supported", (bool, bool))
+      "%select{|non-@objc}0 %2 %3 %select{"
+      "is declared in extension of %4 and cannot be overriden|"
+      "declared in %4 cannot be overriden from extension}1", 
+      (bool, bool, DescriptiveDeclKind, DeclName, DeclName))
 NOTE(overridden_here,none,
      "overridden declaration is here", ())
 NOTE(overridden_here_can_be_objc,none,
@@ -2981,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",
@@ -4057,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 "
@@ -5351,6 +5357,10 @@ ERROR(override_nsobject_hashvalue_error,none,
       "'NSObject.hashValue' is not overridable; "
       "did you mean to override 'NSObject.hash'?", ())
 
+ERROR(override_nsobject_hash_error,none,
+      "`NSObject.hash(into:)` is not overridable; "
+      "subclasses can customize hashing by overriding the `hash` property", ())
+
 WARNING(hashvalue_implementation,none,
         "'Hashable.hashValue' is deprecated as a protocol requirement; "
         "conform type %0 to 'Hashable' by implementing 'hash(into:)' instead",

include/swift/AST/IRGenOptions.h

@@ -146,6 +146,9 @@ struct PointerAuthOptions : clang::PointerAuthOptions {
 
   /// The resume function stored in AsyncTask.
   PointerAuthSchema TaskResumeFunction;
+
+  /// The swift async context entry in the extended frame info.
+  PointerAuthSchema AsyncContextExtendedFrameEntry;
 };
 
 enum class JITDebugArtifact : unsigned {