Merge pull request #80982 from xedin/rdar-145776322-6.2

[6.2][Frontend] Promote `AsyncCallerExecution` to an upcoming feature

Author: xedin

include/swift/AST/DiagnosticGroups.def

@@ -41,7 +41,7 @@
 GROUP(no_group, "")
 
 GROUP(ActorIsolatedCall, "actor-isolated-call")
-GROUP(AsyncCallerExecution, "async-caller-execution")
+GROUP(NonisolatedNonsendingByDefault, "nonisolated-nonsending-by-default")
 GROUP(ConformanceIsolation, "conformance-isolation")
 GROUP(DeprecatedDeclaration, "deprecated-declaration")
 GROUP(DynamicCallable, "dynamic-callable-requirements")

include/swift/AST/DiagnosticsSema.def

@@ -8592,22 +8592,22 @@ NOTE(type_does_not_conform_to_Sendable,none,
      "type %0 does not conform to 'Sendable' protocol", (Type))
 
 GROUPED_WARNING(
-    attr_execution_nonisolated_behavior_will_change_decl, AsyncCallerExecution,
+    attr_execution_nonisolated_behavior_will_change_decl, NonisolatedNonsendingByDefault,
     none,
     "feature '%0' will cause nonisolated async %kindbase1 to run on the "
     "caller's actor; use %2 to preserve behavior",
     (StringRef, const AbstractFunctionDecl *, DeclAttribute))
 
 GROUPED_WARNING(
     attr_execution_nonisolated_behavior_will_change_closure,
-    AsyncCallerExecution, none,
+    NonisolatedNonsendingByDefault, none,
     "feature '%0' will cause nonisolated async closure to run on the caller's "
     "actor; use %1 to preserve behavior",
     (StringRef, DeclAttribute))
 
 GROUPED_WARNING(
     attr_execution_nonisolated_behavior_will_change_typerepr,
-    AsyncCallerExecution, none,
+    NonisolatedNonsendingByDefault, none,
     "feature '%0' will cause nonisolated async function type to be treated as "
     "specified to run on the caller's actor; use %1 to preserve "
     "behavior",

include/swift/Basic/Features.def

@@ -279,6 +279,7 @@ ADOPTABLE_UPCOMING_FEATURE(ExistentialAny, 335, 7)
 UPCOMING_FEATURE(InternalImportsByDefault, 409, 7)
 UPCOMING_FEATURE(MemberImportVisibility, 444, 7)
 UPCOMING_FEATURE(InferIsolatedConformances, 470, 7)
+ADOPTABLE_UPCOMING_FEATURE(NonisolatedNonsendingByDefault, 461, 7)
 
 // Optional language features / modes
 
@@ -487,10 +488,6 @@ SUPPRESSIBLE_EXPERIMENTAL_FEATURE(AddressableTypes, true)
 /// Allow the @abi attribute.
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(ABIAttribute, true)
 
-/// Functions with nonisolated isolation inherit their isolation from the
-/// calling context.
-ADOPTABLE_EXPERIMENTAL_FEATURE(AsyncCallerExecution, false)
-
 /// Allow custom availability domains to be defined and referenced.
 EXPERIMENTAL_FEATURE(CustomAvailability, true)
 

lib/AST/FeatureSet.cpp

@@ -123,8 +123,8 @@ UNINTERESTING_FEATURE(Volatile)
 UNINTERESTING_FEATURE(SuppressedAssociatedTypes)
 UNINTERESTING_FEATURE(StructLetDestructuring)
 UNINTERESTING_FEATURE(MacrosOnImports)
-UNINTERESTING_FEATURE(AsyncCallerExecution)
 UNINTERESTING_FEATURE(ExtensibleEnums)
+UNINTERESTING_FEATURE(NonisolatedNonsendingByDefault)
 UNINTERESTING_FEATURE(KeyPathWithMethodMembers)
 
 static bool usesFeatureNonescapableTypes(Decl *decl) {

lib/SIL/IR/SILFunctionType.cpp

@@ -1705,7 +1705,7 @@ class DestructureInputs {
     }
 
     // If we are an async function that is unspecified or nonisolated, insert an
-    // isolated parameter if AsyncCallerExecution is enabled.
+    // isolated parameter if NonisolatedNonsendingByDefault is enabled.
     //
     // NOTE: The parameter is not inserted for async functions imported
     // from ObjC because they are handled in a special way that doesn't

lib/Sema/CMakeLists.txt

@@ -1,7 +1,7 @@
 
 add_swift_host_library(swiftSema STATIC
   AssociatedTypeInference.cpp
-  AsyncCallerExecutionMigration.cpp
+  NonisolatedNonsendingByDefaultMigration.cpp
   BuilderTransform.cpp
   Comment.cpp
   CSApply.cpp

lib/Sema/AsyncCallerExecutionMigration.cpp renamed to lib/Sema/NonisolatedNonsendingByDefaultMigration.cpp

@@ -1,4 +1,4 @@
-//===-- Sema/AsyncCallerExecutionMigration.cpp ------------------*- C++ -*-===//
+//===-- Sema/NonisolatedNonsendingByDefaultMigration.cpp --------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -11,12 +11,12 @@
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This file implements code migration support for the `AsyncCallerExecution`
-/// feature.
+/// This file implements code migration support for the
+/// `NonisolatedNonsendingByDefault` feature.
 ///
 //===----------------------------------------------------------------------===//
 
-#include "AsyncCallerExecutionMigration.h"
+#include "NonisolatedNonsendingByDefaultMigration.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsSema.h"
@@ -30,34 +30,34 @@
 using namespace swift;
 
 namespace {
-class AsyncCallerExecutionMigrationTarget {
+class NonisolatedNonsendingByDefaultMigrationTarget {
   ASTContext &ctx;
   PointerUnion<ValueDecl *, AbstractClosureExpr *, FunctionTypeRepr *> node;
   TaggedUnion<ActorIsolation, FunctionTypeIsolation> isolation;
 
 public:
-  AsyncCallerExecutionMigrationTarget(ASTContext &ctx, ValueDecl *decl,
+  NonisolatedNonsendingByDefaultMigrationTarget(ASTContext &ctx, ValueDecl *decl,
                                       ActorIsolation isolation)
       : ctx(ctx), node(decl), isolation(isolation) {}
 
-  AsyncCallerExecutionMigrationTarget(ASTContext &ctx,
+  NonisolatedNonsendingByDefaultMigrationTarget(ASTContext &ctx,
                                       AbstractClosureExpr *closure,
                                       ActorIsolation isolation)
       : ctx(ctx), node(closure), isolation(isolation) {}
 
-  AsyncCallerExecutionMigrationTarget(ASTContext &ctx, FunctionTypeRepr *repr,
+  NonisolatedNonsendingByDefaultMigrationTarget(ASTContext &ctx, FunctionTypeRepr *repr,
                                       FunctionTypeIsolation isolation)
       : ctx(ctx), node(repr), isolation(isolation) {}
 
   /// Warns that the behavior of nonisolated async functions will change under
-  /// `AsyncCallerExecution` and suggests `@concurrent` to preserve the current
+  /// `NonisolatedNonsendingByDefault` and suggests `@concurrent` to preserve the current
   /// behavior.
   void diagnose() const;
 };
 } // end anonymous namespace
 
-void AsyncCallerExecutionMigrationTarget::diagnose() const {
-  const auto feature = Feature::AsyncCallerExecution;
+void NonisolatedNonsendingByDefaultMigrationTarget::diagnose() const {
+  const auto feature = Feature::NonisolatedNonsendingByDefault;
 
   ASSERT(node);
   ASSERT(ctx.LangOpts.getFeatureState(feature).isEnabledForAdoption());
@@ -189,15 +189,15 @@ void AsyncCallerExecutionMigrationTarget::diagnose() const {
 
 void swift::warnAboutNewNonisolatedAsyncExecutionBehavior(
     ASTContext &ctx, FunctionTypeRepr *repr, FunctionTypeIsolation isolation) {
-  AsyncCallerExecutionMigrationTarget(ctx, repr, isolation).diagnose();
+  NonisolatedNonsendingByDefaultMigrationTarget(ctx, repr, isolation).diagnose();
 }
 
 void swift::warnAboutNewNonisolatedAsyncExecutionBehavior(
     ASTContext &ctx, ValueDecl *decl, ActorIsolation isolation) {
-  AsyncCallerExecutionMigrationTarget(ctx, decl, isolation).diagnose();
+  NonisolatedNonsendingByDefaultMigrationTarget(ctx, decl, isolation).diagnose();
 }
 
 void swift::warnAboutNewNonisolatedAsyncExecutionBehavior(
     ASTContext &ctx, AbstractClosureExpr *closure, ActorIsolation isolation) {
-  AsyncCallerExecutionMigrationTarget(ctx, closure, isolation).diagnose();
+  NonisolatedNonsendingByDefaultMigrationTarget(ctx, closure, isolation).diagnose();
 }

lib/Sema/AsyncCallerExecutionMigration.h renamed to lib/Sema/NonisolatedNonsendingByDefaultMigration.h

@@ -1,4 +1,4 @@
-//===-- Sema/AsyncCallerExecutionMigration.h --------------------*- C++ -*-===//
+//===-- Sema/NonisolatedNonsendingByDefaultMigration.h ----------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -11,13 +11,13 @@
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This file provides code migration support for the `AsyncCallerExecution`
-/// feature.
+/// This file provides code migration support for the
+/// `NonisolatedNonsendingByDefault` feature.
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef SWIFT_SEMA_ASYNCCALLEREXECUTIONMIGRATION_H
-#define SWIFT_SEMA_ASYNCCALLEREXECUTIONMIGRATION_H
+#ifndef SWIFT_SEMA_NONISOLATEDNONSENDINGBYDEFAULTMIGRATION_H
+#define SWIFT_SEMA_NONISOLATEDNONSENDINGBYDEFAULTMIGRATION_H
 
 #include "swift/AST/ActorIsolation.h"
 #include "swift/AST/ExtInfo.h"
@@ -29,25 +29,25 @@ class ValueDecl;
 class AbstractClosureExpr;
 
 /// Warns that the behavior of nonisolated async functions will change under
-/// `AsyncCallerExecution` and suggests `@concurrent` to preserve the current
+/// `NonisolatedNonsendingByDefault` and suggests `@concurrent` to preserve the current
 /// behavior.
 void warnAboutNewNonisolatedAsyncExecutionBehavior(
     ASTContext &ctx, FunctionTypeRepr *node, FunctionTypeIsolation isolation);
 
 /// Warns that the behavior of nonisolated async functions will change under
-/// `AsyncCallerExecution` and suggests `@concurrent` to preserve the current
+/// `NonisolatedNonsendingByDefault` and suggests `@concurrent` to preserve the current
 /// behavior.
 void warnAboutNewNonisolatedAsyncExecutionBehavior(ASTContext &ctx,
                                                    ValueDecl *node,
                                                    ActorIsolation isolation);
 
 /// Warns that the behavior of nonisolated async functions will change under
-/// `AsyncCallerExecution` and suggests `@concurrent` to preserve the current
+/// `NonisolatedNonsendingByDefault` and suggests `@concurrent` to preserve the current
 /// behavior.
 void warnAboutNewNonisolatedAsyncExecutionBehavior(ASTContext &ctx,
                                                    AbstractClosureExpr *node,
                                                    ActorIsolation isolation);
 
 } // end namespace swift
 
-#endif /* SWIFT_SEMA_ASYNCCALLEREXECUTIONMIGRATION_H */
+#endif /* SWIFT_SEMA_NONISOLATEDNONSENDINGBYDEFAULTMIGRATION_H */

lib/Sema/TypeCheckConcurrency.cpp

@@ -15,7 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "TypeCheckConcurrency.h"
-#include "AsyncCallerExecutionMigration.h"
+#include "NonisolatedNonsendingByDefaultMigration.h"
 #include "MiscDiagnostics.h"
 #include "TypeCheckDistributed.h"
 #include "TypeCheckInvertible.h"
@@ -4767,7 +4767,7 @@ ActorIsolation ActorIsolationChecker::determineClosureIsolation(
   // Apply computed preconcurrency.
   isolation = isolation.withPreconcurrency(preconcurrency);
 
-  if (ctx.LangOpts.getFeatureState(Feature::AsyncCallerExecution)
+  if (ctx.LangOpts.getFeatureState(Feature::NonisolatedNonsendingByDefault)
           .isEnabledForAdoption()) {
     warnAboutNewNonisolatedAsyncExecutionBehavior(ctx, closure, isolation);
   }
@@ -4948,7 +4948,7 @@ getIsolationFromAttributes(const Decl *decl, bool shouldDiagnose = true,
     // If the nonisolated async inherits isolation from context,
     // return caller isolation inheriting.
     if (decl->getASTContext().LangOpts.hasFeature(
-            Feature::AsyncCallerExecution)) {
+            Feature::NonisolatedNonsendingByDefault)) {
       if (auto *func = dyn_cast<AbstractFunctionDecl>(decl);
           func && func->hasAsync() &&
           func->getModuleContext() == decl->getASTContext().MainModule) {
@@ -5814,7 +5814,7 @@ computeDefaultInferredActorIsolation(ValueDecl *value) {
   }
 
   // If we have an async function... by default we inherit isolation.
-  if (ctx.LangOpts.hasFeature(Feature::AsyncCallerExecution)) {
+  if (ctx.LangOpts.hasFeature(Feature::NonisolatedNonsendingByDefault)) {
     if (auto *func = dyn_cast<AbstractFunctionDecl>(value);
         func && func->hasAsync() &&
         func->getModuleContext() == ctx.MainModule) {
@@ -5931,7 +5931,7 @@ static InferredActorIsolation computeActorIsolation(Evaluator &evaluator,
   // did not have an ExecutionKind::Caller attached to it.
   //
   // DISCUSSION: This occurs when we have a value decl that is explicitly marked
-  // as nonisolated but since AsyncCallerExecution is enabled, we return
+  // as nonisolated but since NonisolatedNonsendingByDefault is enabled, we return
   // CallerIsolationInheriting.
   if (isolationFromAttr && isolationFromAttr->getKind() ==
           ActorIsolation::CallerIsolationInheriting) {
@@ -6232,7 +6232,7 @@ static InferredActorIsolation computeActorIsolation(Evaluator &evaluator,
 
         if (auto *func = dyn_cast<AbstractFunctionDecl>(value);
             ctx.LangOpts.hasFeature(
-                Feature::AsyncCallerExecution) &&
+                Feature::NonisolatedNonsendingByDefault) &&
             func && func->hasAsync() &&
             func->getModuleContext() == ctx.MainModule &&
             isolation.isNonisolated()) {
@@ -6277,7 +6277,7 @@ InferredActorIsolation ActorIsolationRequest::evaluate(Evaluator &evaluator,
   const auto inferredIsolation = computeActorIsolation(evaluator, value);
 
   auto &ctx = value->getASTContext();
-  if (ctx.LangOpts.getFeatureState(Feature::AsyncCallerExecution)
+  if (ctx.LangOpts.getFeatureState(Feature::NonisolatedNonsendingByDefault)
           .isEnabledForAdoption()) {
     warnAboutNewNonisolatedAsyncExecutionBehavior(ctx, value,
                                                   inferredIsolation.isolation);

lib/Sema/TypeCheckType.cpp

@@ -16,7 +16,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "TypeCheckType.h"
-#include "AsyncCallerExecutionMigration.h"
+#include "NonisolatedNonsendingByDefaultMigration.h"
 #include "TypeCheckAvailability.h"
 #include "TypeCheckConcurrency.h"
 #include "TypeCheckInvertible.h"
@@ -4251,7 +4251,7 @@ NeverNullType TypeResolver::resolveASTFunctionType(
     if (!repr->isInvalid())
       isolation = FunctionTypeIsolation::forNonIsolated();
   } else {
-    if (ctx.LangOpts.getFeatureState(Feature::AsyncCallerExecution)
+    if (ctx.LangOpts.getFeatureState(Feature::NonisolatedNonsendingByDefault)
             .isEnabledForAdoption()) {
       // Diagnose only in the interface stage, which is run once.
       if (inStage(TypeResolutionStage::Interface)) {