Merge pull request #37415 from DougGregor/remove-asynchandler

Author: swift-ci

include/swift/AST/ASTMangler.h

@@ -85,7 +85,6 @@ class ASTMangler : public Mangler {
 public:
   enum class SymbolKind {
     Default,
-    AsyncHandlerBody,
     DynamicThunk,
     SwiftAsObjCThunk,
     ObjCAsSwiftThunk,
@@ -347,7 +346,6 @@ class ASTMangler : public Mangler {
   enum FunctionManglingKind {
     NoFunctionMangling,
     FunctionMangling,
-    AsyncHandlerBodyMangling
   };
 
   void appendFunction(AnyFunctionType *fn,
@@ -433,7 +431,7 @@ class ASTMangler : public Mangler {
 
   void appendEntity(const ValueDecl *decl, StringRef EntityOp, bool isStatic);
 
-  void appendEntity(const ValueDecl *decl, bool isAsyncHandlerBody = false);
+  void appendEntity(const ValueDecl *decl);
 
   void appendProtocolConformance(const ProtocolConformance *conformance);
   void appendProtocolConformanceRef(const RootProtocolConformance *conformance);

include/swift/AST/Attr.def

@@ -565,10 +565,7 @@ SIMPLE_DECL_ATTR(noDerivative, NoDerivative,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   100)
 
-SIMPLE_DECL_ATTR(asyncHandler, AsyncHandler,
-  OnFunc | ConcurrencyOnly |
-  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
-  101)
+// 101 was @asyncHandler and is now unused
 
 // TODO: Remove this once we don't need to support 'actor' as a modifier
 CONTEXTUAL_SIMPLE_DECL_ATTR(actor, Actor,

include/swift/AST/Decl.h

@@ -423,7 +423,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasNestedTypeDeclarations : 1
   );
 
-  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+1+2+1+1+2+1+1+1,
+  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+1+2+1+1+2+1,
     /// Whether we've computed the 'static' flag yet.
     IsStaticComputed : 1,
 
@@ -442,12 +442,6 @@ class alignas(1 << DeclAlignInBits) Decl {
     /// Backing bits for 'self' access kind.
     SelfAccess : 2,
 
-    /// Whether we've computed the IsAsyncHandlerRequest.
-    IsAsyncHandlerComputed : 1,
-
-    /// The value of IsAsyncHandlerRequest.
-    IsAsyncHandler : 1,
-
     /// Whether this is a top-level function which should be treated
     /// as if it were in local context for the purposes of capture
     /// analysis.
@@ -5849,16 +5843,9 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   ///
   /// Functions that are an 'async' context can make calls to 'async' functions.
   bool isAsyncContext() const {
-    return hasAsync() || isAsyncHandler();
+    return hasAsync();
   }
 
-  /// Returns true if the function is an @asyncHandler.
-  bool isAsyncHandler() const;
-
-  /// Returns true if the function signature matches the form of an
-  /// @asyncHandler.
-  bool canBeAsyncHandler() const;
-
   /// Returns true if the function body throws.
   bool hasThrows() const { return Bits.AbstractFunctionDecl.Throws; }
 
@@ -6143,7 +6130,6 @@ class FuncDecl : public AbstractFunctionDecl {
   friend class SelfAccessKindRequest;
   friend class IsStaticRequest;
   friend class ResultTypeRequest;
-  friend class IsAsyncHandlerRequest;
 
   SourceLoc StaticLoc;  // Location of the 'static' token or invalid.
   SourceLoc FuncLoc;    // Location of the 'func' token.
@@ -6175,8 +6161,6 @@ class FuncDecl : public AbstractFunctionDecl {
     Bits.FuncDecl.SelfAccessComputed = false;
     Bits.FuncDecl.IsStaticComputed = false;
     Bits.FuncDecl.IsStatic = false;
-    Bits.FuncDecl.IsAsyncHandlerComputed = false;
-    Bits.FuncDecl.IsAsyncHandler = false;
     Bits.FuncDecl.HasTopLevelLocalContextCaptures = false;
   }
 
@@ -6207,18 +6191,6 @@ class FuncDecl : public AbstractFunctionDecl {
     return None;
   }
 
-  Optional<bool> getCachedIsAsyncHandler() const {
-    if (Bits.FuncDecl.IsAsyncHandlerComputed)
-      return Bits.FuncDecl.IsAsyncHandler;
-
-    return None;
-  }
-
-  void setIsAsyncHandler(bool value) {
-    Bits.FuncDecl.IsAsyncHandlerComputed = true;
-    Bits.FuncDecl.IsAsyncHandler = value;
-  }
-
 public:
   /// Factory function only for use by deserialization.
   static FuncDecl *createDeserialized(ASTContext &Context,

include/swift/AST/DiagnosticsSema.def

@@ -4299,8 +4299,6 @@ ERROR(async_in_nonasync_function,none,
       (unsigned, bool))
 NOTE(note_add_async_to_function,none,
      "add 'async' to function %0 to make it asynchronous", (DeclName))
-NOTE(note_add_asynchandler_to_function,none,
-     "add '@asyncHandler' to function %0 to create an implicit asynchronous context", (DeclName))
 NOTE(note_add_nonisolated_to_decl,none,
      "add 'nonisolated' to %0 to make this %1 not isolated to the actor",
      (DeclName, DescriptiveDeclKind))
@@ -4336,30 +4334,6 @@ ERROR(async_let_in_illegal_context,none,
       "%select{<<ERROR>>|a default argument|a property wrapper initializer|a property initializer|a global variable initializer|an enum case raw value|a catch pattern|a catch guard expression|a defer body}1",
       (DeclName, unsigned))
 
-ERROR(asynchandler_non_func,none,
-      "'@asyncHandler' can only be applied to functions",
-      ())
-ERROR(asynchandler_returns_value,none,
-      "'@asyncHandler' function can only return 'Void'",
-      ())
-ERROR(asynchandler_throws,none,
-      "'@asyncHandler' function cannot throw",
-      ())
-ERROR(asynchandler_async,none,
-      "'@asyncHandler' function cannot be 'async' itself",
-      ())
-ERROR(asynchandler_inout_parameter,none,
-      "'inout' parameter is not allowed in '@asyncHandler' function",
-      ())
-ERROR(asynchandler_noescape_closure_parameter,none,
-      "non-escaping closure parameter is not allowed in '@asyncHandler' function",
-      ())
-ERROR(asynchandler_mutating,none,
-      "'@asyncHandler' function cannot be 'mutating'",
-      ())
-ERROR(asynchandler_removed,none,
-      "'@asyncHandler' has been removed from the language", ())
-
 ERROR(objc_ambiguous_async_convention,none,
       "%0 overrides or implements protocol requirements for Objective-C "
       "declarations with incompatible async conventions",

include/swift/AST/TypeCheckRequests.h

@@ -878,45 +878,6 @@ class SelfAccessKindRequest :
   void cacheResult(SelfAccessKind value) const;
 };
 
-/// Determine whether the given function is an @asyncHandler.
-class IsAsyncHandlerRequest :
-    public SimpleRequest<IsAsyncHandlerRequest,
-                         bool(FuncDecl *),
-                         RequestFlags::SeparatelyCached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  bool evaluate(Evaluator &evaluator, FuncDecl *func) const;
-
-public:
-  // Separate caching.
-  bool isCached() const { return true; }
-  Optional<bool> getCachedResult() const;
-  void cacheResult(bool value) const;
-};
-
-/// Determine whether the given function can be an @asyncHandler, without
-/// producing any diagnostics.
-class CanBeAsyncHandlerRequest :
-    public SimpleRequest<CanBeAsyncHandlerRequest,
-                         bool(FuncDecl *),
-                         RequestFlags::Cached> {
-public:
-  using SimpleRequest::SimpleRequest;
-
-private:
-  friend SimpleRequest;
-
-  bool evaluate(Evaluator &evaluator, FuncDecl *func) const;
-
-public:
-  // Caching
-  bool isCached() const { return true; }
-};
-
 /// Determine whether the given nominal type is an actor.
 class IsActorRequest :
     public SimpleRequest<IsActorRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -93,10 +93,6 @@ SWIFT_REQUEST(TypeChecker, ExtendedTypeRequest, Type(ExtensionDecl *), Cached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResultBuilderTypeRequest, Type(ValueDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, IsAsyncHandlerRequest, bool(FuncDecl *),
-              Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, CanBeAsyncHandlerRequest, bool(FuncDecl *),
-              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsActorRequest, bool(NominalTypeDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsDefaultActorRequest,

include/swift/Basic/LangOptions.h

@@ -264,9 +264,6 @@ namespace swift {
     /// Enable experimental concurrency model.
     bool EnableExperimentalConcurrency = false;
 
-    /// Enable experimental asyncHandler support.
-    bool EnableExperimentalAsyncHandler = false;
-
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;
 

include/swift/Option/FrontendOptions.td

@@ -226,10 +226,6 @@ def enable_experimental_concurrency :
   Flag<["-"], "enable-experimental-concurrency">,
   HelpText<"Enable experimental concurrency model">;
 
-def enable_experimental_async_handler :
-  Flag<["-"], "enable-experimental-async-handler">,
-  HelpText<"Enable experimental @asyncHandler feature">;
-
 def enable_experimental_flow_sensitive_concurrent_captures :
   Flag<["-"], "enable-experimental-flow-sensitive-concurrent-captures">,
   HelpText<"Enable flow-sensitive concurrent captures">;

include/swift/SIL/SILDeclRef.h

@@ -225,7 +225,6 @@ struct SILDeclRef {
   enum class ManglingKind {
     Default,
     DynamicThunk,
-    AsyncHandlerBody
   };
 
   /// Produce a mangled form of this constant.

lib/AST/ASTMangler.cpp

@@ -89,7 +89,7 @@ std::string ASTMangler::mangleClosureEntity(const AbstractClosureExpr *closure,
 
 std::string ASTMangler::mangleEntity(const ValueDecl *decl, SymbolKind SKind) {
   beginMangling();
-  appendEntity(decl, SKind == SymbolKind::AsyncHandlerBody);
+  appendEntity(decl);
   appendSymbolKind(SKind);
   return finalize();
 }
@@ -818,7 +818,6 @@ std::string ASTMangler::mangleGenericSignature(const GenericSignature sig) {
 void ASTMangler::appendSymbolKind(SymbolKind SKind) {
   switch (SKind) {
     case SymbolKind::Default: return;
-    case SymbolKind::AsyncHandlerBody: return;
     case SymbolKind::DynamicThunk: return appendOperator("TD");
     case SymbolKind::SwiftAsObjCThunk: return appendOperator("To");
     case SymbolKind::ObjCAsSwiftThunk: return appendOperator("TO");
@@ -2449,7 +2448,7 @@ void ASTMangler::appendFunctionSignature(AnyFunctionType *fn,
                                         FunctionManglingKind functionMangling) {
   appendFunctionResultType(fn->getResult(), forDecl);
   appendFunctionInputType(fn->getParams(), forDecl);
-  if (fn->isAsync() || functionMangling == AsyncHandlerBodyMangling)
+  if (fn->isAsync())
     appendOperator("Ya");
   if (fn->isSendable())
     appendOperator("Yb");
@@ -2998,7 +2997,7 @@ void ASTMangler::appendEntity(const ValueDecl *decl, StringRef EntityOp,
     appendOperator("Z");
 }
 
-void ASTMangler::appendEntity(const ValueDecl *decl, bool isAsyncHandlerBody) {
+void ASTMangler::appendEntity(const ValueDecl *decl) {
   assert(!isa<ConstructorDecl>(decl));
   assert(!isa<DestructorDecl>(decl));
 
@@ -3019,8 +3018,7 @@ void ASTMangler::appendEntity(const ValueDecl *decl, bool isAsyncHandlerBody) {
 
   appendContextOf(decl);
   appendDeclName(decl);
-  appendDeclType(decl, isAsyncHandlerBody ? AsyncHandlerBodyMangling
-                                          : FunctionMangling);
+  appendDeclType(decl, FunctionMangling);
   appendOperator("F");
   if (decl->isStatic())
     appendOperator("Z");

lib/AST/Decl.cpp

@@ -6957,28 +6957,6 @@ bool AbstractFunctionDecl::isSendable() const {
   return getAttrs().hasAttribute<SendableAttr>();
 }
 
-bool AbstractFunctionDecl::isAsyncHandler() const {
-  auto func = dyn_cast<FuncDecl>(this);
-  if (!func)
-    return false;
-
-  auto mutableFunc = const_cast<FuncDecl *>(func);
-  return evaluateOrDefault(getASTContext().evaluator,
-                           IsAsyncHandlerRequest{mutableFunc},
-                           false);
-}
-
-bool AbstractFunctionDecl::canBeAsyncHandler() const {
-  auto func = dyn_cast<FuncDecl>(this);
-  if (!func)
-    return false;
-
-  auto mutableFunc = const_cast<FuncDecl *>(func);
-  return evaluateOrDefault(getASTContext().evaluator,
-                           CanBeAsyncHandlerRequest{mutableFunc},
-                           false);
-}
-
 BraceStmt *AbstractFunctionDecl::getBody(bool canSynthesize) const {
   if ((getBodyKind() == BodyKind::Synthesize ||
        getBodyKind() == BodyKind::Unparsed) &&

lib/AST/TypeCheckRequests.cpp

@@ -633,20 +633,6 @@ void SelfAccessKindRequest::cacheResult(SelfAccessKind value) const {
   funcDecl->setSelfAccessKind(value);
 }
 
-//----------------------------------------------------------------------------//
-// IsAsyncHandlerRequest computation.
-//----------------------------------------------------------------------------//
-
-Optional<bool> IsAsyncHandlerRequest::getCachedResult() const {
-  auto *funcDecl = std::get<0>(getStorage());
-  return funcDecl->getCachedIsAsyncHandler();
-}
-
-void IsAsyncHandlerRequest::cacheResult(bool value) const {
-  auto *funcDecl = std::get<0>(getStorage());
-  funcDecl->setIsAsyncHandler(value);
-}
-
 //----------------------------------------------------------------------------//
 // IsGetterMutatingRequest computation.
 //----------------------------------------------------------------------------//

lib/Frontend/CompilerInvocation.cpp

@@ -411,8 +411,6 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     Args.hasFlag(OPT_enable_infer_public_concurrent_value,
                  OPT_disable_infer_public_concurrent_value,
                  false);
-  Opts.EnableExperimentalAsyncHandler |=
-    Args.hasArg(OPT_enable_experimental_async_handler);
   Opts.EnableExperimentalFlowSensitiveConcurrentCaptures |=
     Args.hasArg(OPT_enable_experimental_flow_sensitive_concurrent_captures);
 

lib/SIL/IR/SILDeclRef.cpp

@@ -777,9 +777,6 @@ std::string SILDeclRef::mangle(ManglingKind MKind) const {
     case SILDeclRef::ManglingKind::DynamicThunk:
       SKind = ASTMangler::SymbolKind::DynamicThunk;
       break;
-    case SILDeclRef::ManglingKind::AsyncHandlerBody:
-      SKind = ASTMangler::SymbolKind::AsyncHandlerBody;
-      break;
   }
 
   switch (kind) {

lib/SILGen/SILGen.cpp

@@ -421,11 +421,6 @@ SILGenModule::getRunTaskForBridgedAsyncMethod() {
                                     "_runTaskForBridgedAsyncMethod");
 }
 FuncDecl *
-SILGenModule::getRunAsyncHandler() {
-  return lookupConcurrencyIntrinsic(getASTContext(), RunAsyncHandler,
-                                    "_runAsyncHandler");
-}
-FuncDecl *
 SILGenModule::getCheckExpectedExecutor() {
   return lookupConcurrencyIntrinsic(getASTContext(), CheckExpectedExecutor,
                                     "_checkExpectedExecutor");

lib/SILGen/SILGen.h

@@ -131,7 +131,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   Optional<FuncDecl*> ResumeUnsafeContinuation;
   Optional<FuncDecl*> ResumeUnsafeThrowingContinuation;
   Optional<FuncDecl*> ResumeUnsafeThrowingContinuationWithError;
-  Optional<FuncDecl*> RunAsyncHandler;
   Optional<FuncDecl*> CheckExpectedExecutor;
 
 public:
@@ -507,8 +506,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   FuncDecl *getResumeUnsafeThrowingContinuation();
   /// Retrieve the _Concurrency._resumeUnsafeThrowingContinuationWithError intrinsic.
   FuncDecl *getResumeUnsafeThrowingContinuationWithError();
-  /// Retrieve the _Concurrency._runAsyncHandler intrinsic.
-  FuncDecl *getRunAsyncHandler();
   /// Retrieve the _Concurrency._runTaskForBridgedAsyncMethod intrinsic.
   FuncDecl *getRunTaskForBridgedAsyncMethod();
   /// Retrieve the _Concurrency._checkExpectedExecutor intrinsic.