[Sema/SILGen] NFC: Remove all mentions of @execution from comments

Author: xedin

lib/SILGen/SILGenExpr.cpp

@@ -489,11 +489,11 @@ namespace {
                                        SGFContext C);
 
     /// Helper method for handling function conversion expr to
-    /// @execution(caller). Returns an empty RValue on failure.
+    /// nonisolated(nonsending). Returns an empty RValue on failure.
     RValue emitFunctionCvtToExecutionCaller(FunctionConversionExpr *E,
                                             SGFContext C);
     /// Helper method for handling function conversion expr to a global actor
-    /// from an @execution(caller) function.
+    /// from an nonisolated(nonsending) function.
     RValue
     emitFunctionCvtFromExecutionCallerToGlobalActor(FunctionConversionExpr *E,
                                                     SGFContext C);
@@ -1968,17 +1968,17 @@ RValueEmitter::emitFunctionCvtToExecutionCaller(FunctionConversionExpr *e,
   //
   // Swift 6:
   //
-  // (fn_cvt_expr type="@execution(caller) () async -> ()"
-  //   (fn_cvt_expr type="@execution(caller) @Sendable () async -> ()"
+  // (fn_cvt_expr type="nonisolated(nonsending) () async -> ()"
+  //   (fn_cvt_expr type="nonisolated(nonsending) @Sendable () async -> ()"
   //      (declref_expr type="() async -> ()"
   //
   // Swift 5:
   //
-  // (fn_cvt_expr type="@execution(caller) () async -> ()"
+  // (fn_cvt_expr type="nonisolated(nonsending) () async -> ()"
   //   (declref_expr type="() async -> ()"
   //
   // The @Sendable in Swift 6 mode is due to us not representing
-  // @execution(caller) or @Sendable in the constraint evaluator.
+  // nonisolated(nonsending) or @Sendable in the constraint evaluator.
   //
   // The reason why we need to evaluate this especially is that otherwise we
   // generate multiple
@@ -2038,7 +2038,7 @@ RValue RValueEmitter::emitFunctionCvtFromExecutionCallerToGlobalActor(
   // We are pattern matching a conversion sequence like the following:
   //
   // (fn_cvt_expr implicit type="@GlobalActor @Sendable () async -> ()
-  //    (fn_cvt_expr implicit type="@execution(caller) @Sendable () async -> ()"
+  //    (fn_cvt_expr implicit type="nonisolated(nonsending) @Sendable () async -> ()"
   //       (declref_expr type="() async -> ()"
   //
   // Where the declref referred to by the declref_expr has execution(caller)
@@ -2047,9 +2047,9 @@ RValue RValueEmitter::emitFunctionCvtFromExecutionCallerToGlobalActor(
   // fix it up later.
   //
   // What we want to emit first a direct reference to the caller as an
-  // @execution(caller) function, then we convert it to @execution(caller)
-  // @Sendable. Finally, we thunk @execution(caller) to @GlobalActor. The
-  // thunking is important so that we can ensure that @execution(caller) runs on
+  // nonisolated(nonsending) function, then we convert it to nonisolated(nonsending)
+  // @Sendable. Finally, we thunk nonisolated(nonsending) to @GlobalActor. The
+  // thunking is important so that we can ensure that nonisolated(nonsending) runs on
   // that specific @GlobalActor.
 
   CanAnyFunctionType destType =
@@ -2201,13 +2201,13 @@ RValue RValueEmitter::visitFunctionConversionExpr(FunctionConversionExpr *e,
     }
   }
 
-  // Check if we are converting a function to an @execution(caller) from a
-  // declref that is also @execution(caller). In such a case, this was a case
+  // Check if we are converting a function to an nonisolated(nonsending) from a
+  // declref that is also nonisolated(nonsending). In such a case, this was a case
   // that was put in by Sema. We do not need a thunk, but just need to recognize
   // this case and elide the conversion. The reason why we need to do this is
-  // that otherwise, we put in extra thunks that convert @execution(caller) to
-  // @execution(concurrent) back to @execution(caller). This is done b/c we do
-  // not represent @execution(caller) in interface types, so the actual decl ref
+  // that otherwise, we put in extra thunks that convert nonisolated(nonsending) to
+  // @concurrent back to nonisolated(nonsending). This is done b/c we do
+  // not represent nonisolated(nonsending) in interface types, so the actual decl ref
   // will be viewed as @async () -> ().
   if (destType->getIsolation().isNonIsolatedCaller()) {
     if (RValue rv = emitFunctionCvtToExecutionCaller(e, C))

lib/Sema/AsyncCallerExecutionMigration.h

@@ -29,21 +29,21 @@ class ValueDecl;
 class AbstractClosureExpr;
 
 /// Warns that the behavior of nonisolated async functions will change under
-/// `AsyncCallerExecution` and suggests `@execution(concurrent)` to preserve
-/// the current behavior.
+/// `AsyncCallerExecution` 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 `@execution(concurrent)` to preserve
-/// the current behavior.
+/// `AsyncCallerExecution` 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 `@execution(concurrent)` to preserve
-/// the current behavior.
+/// `AsyncCallerExecution` and suggests `@concurrent` to preserve the current
+/// behavior.
 void warnAboutNewNonisolatedAsyncExecutionBehavior(ASTContext &ctx,
                                                    AbstractClosureExpr *node,
                                                    ActorIsolation isolation);

lib/Sema/CSSimplify.cpp

@@ -3303,14 +3303,14 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
   SmallVector<AnyFunctionType::Param, 8> func2Params;
   func2Params.append(func2->getParams().begin(), func2->getParams().end());
 
-  // Support conversion from `@execution(caller)` to a function type
+  // Support conversion from `nonisolated(nonsending)` to a function type
   // with an isolated parameter.
   if (subKind == ConstraintKind::Subtype &&
       func1->getIsolation().isNonIsolatedCaller() &&
       func2->getIsolation().isParameter()) {
-    // `@execution(caller)` function gets an implicit isolation parameter
-    // introduced during SILGen and thunk is going to forward an isolation
-    // from the caller to it.
+    // `nonisolated(nonsending)` function gets an implicit isolation parameter
+    // introduced during SILGen and thunk is going to forward an isolation from
+    // the caller to it.
     // Let's remove the isolated parameter from consideration, function
     // types have to match on everything else.
     llvm::erase_if(func2Params, [](const AnyFunctionType::Param &param) {

lib/Sema/TypeCheckConcurrency.cpp

@@ -2712,16 +2712,16 @@ namespace {
             return;
 
           switch (toIsolation.getKind()) {
-          // Converting to `@execution(caller)` function type
+          // Converting to `nonisolated(nonsending)` function type
           case FunctionTypeIsolation::Kind::NonIsolatedCaller: {
             switch (fromIsolation.getKind()) {
             case FunctionTypeIsolation::Kind::NonIsolated: {
-              // nonisolated -> @execution(caller) doesn't cross
+              // nonisolated -> nonisolated(nonsending) doesn't cross
               // an isolation boundary.
               if (!fromFnType->isAsync())
                 break;
 
-              // @execution(concurrent) -> @execution(caller)
+              // @concurrent -> nonisolated(nonsending)
               // crosses an isolation boundary.
               LLVM_FALLTHROUGH;
             }
@@ -2744,9 +2744,9 @@ namespace {
             break;
           }
 
-          // Converting to nonisolated synchronous or @execution(concurrent)
-          // asynchronous function type could require crossing an isolation
-          // boundary.
+          // Converting to nonisolated synchronous or @concurrent
+          // asynchronous function type could require crossing an
+          // isolation boundary.
           case FunctionTypeIsolation::Kind::NonIsolated: {
             switch (fromIsolation.getKind()) {
             case FunctionTypeIsolation::Kind::Parameter:
@@ -2762,7 +2762,7 @@ namespace {
             }
 
             case FunctionTypeIsolation::Kind::NonIsolated: {
-              // nonisolated synchronous <-> @execution(concurrent)
+              // nonisolated synchronous <-> @concurrent
               if (fromFnType->isAsync() != toFnType->isAsync()) {
                 diagnoseNonSendableParametersAndResult(
                     toFnType, /*downgradeToWarning=*/true);
@@ -2784,10 +2784,10 @@ namespace {
               break;
 
             case FunctionTypeIsolation::Kind::NonIsolated: {
-              // Since @execution(concurrent) as an asynchronous
-              // function it would mean that without Sendable
-              // check it would be possible for non-Sendable state
-              // to escape from actor isolation.
+              // Since @concurrent as an asynchronous function it
+              // would mean that without Sendable check it would
+              // be possible for non-Sendable state to escape from
+              // actor isolation.
               if (fromFnType->isAsync()) {
                 diagnoseNonSendableParametersAndResult(
                   toFnType, /*downgradeToWarning=*/true);

lib/Sema/TypeCheckType.cpp

@@ -4234,8 +4234,9 @@ NeverNullType TypeResolver::resolveASTFunctionType(
       break;
 
     case FunctionTypeIsolation::Kind::NonIsolatedCaller:
-      llvm_unreachable("cannot happen because multiple @execution attributes "
-                       "aren't allowed.");
+      llvm_unreachable(
+          "cannot happen because multiple execution behavior attributes "
+          "aren't allowed.");
     }
   };