[Concurrency] Allow default arguments to require actor isolation.

Type checking a default argument expression will compute the required
actor isolation for evaluating that argument value synchronously. Actor
isolation checking is deferred to the caller; it is an error to use a
default argument from across isolation domains.

Currently gated behind -enable-experimental-feature IsolatedDefaultArguments.

Author: hborla

include/swift/AST/Decl.h

@@ -6415,6 +6415,11 @@ class ParamDecl : public VarDecl {
   /// at the call site in order to have the correct context information.
   Expr *getTypeCheckedDefaultExpr() const;
 
+  /// The actor isolation required of the caller in order to use the
+  /// default argument for this parameter. If the required isolation is
+  /// not met, an argument must be written explicitly at the call-site.
+  ActorIsolation getDefaultArgumentIsolation() const;
+
   /// Retrieve the potentially un-type-checked default argument expression for
   /// this parameter, which can be queried for information such as its source
   /// range and textual representation. Returns \c nullptr if there is no

include/swift/AST/DiagnosticsSema.def

@@ -5236,6 +5236,10 @@ ERROR(distributed_actor_isolated_non_self_reference,none,
       "distributed actor-isolated %kind0 can not be accessed from a "
       "non-isolated context",
       (const ValueDecl *))
+ERROR(isolated_default_argument,none,
+      "%0 default argument cannot be synchronously evaluated from a "
+      "%1 context",
+      (ActorIsolation, ActorIsolation))
 ERROR(distributed_actor_needs_explicit_distributed_import,none,
       "'Distributed' module not imported, required for 'distributed actor'",
       ())

include/swift/AST/Expr.h

@@ -4569,6 +4569,11 @@ class DefaultArgumentExpr final : public Expr {
   /// expression within the context of the call site.
   Expr *getCallerSideDefaultExpr() const;
 
+  /// Get the required actor isolation for evaluating this default argument
+  /// synchronously. If the caller does not meet the required isolation, the
+  /// argument must be written explicitly at the call-site.
+  ActorIsolation getRequiredIsolation() const;
+
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::DefaultArgument;
   }

include/swift/AST/TypeCheckRequests.h

@@ -2934,6 +2934,24 @@ class DefaultArgumentTypeRequest
   void cacheResult(Type type) const;
 };
 
+/// Compute the actor isolation needed to synchronously evaluate the
+/// default argument for the given parameter.
+class DefaultArgumentIsolation
+    : public SimpleRequest<DefaultArgumentIsolation,
+                           ActorIsolation(ParamDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  ActorIsolation evaluate(Evaluator &evaluator, ParamDecl *param) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 /// Computes the fully type-checked caller-side default argument within the
 /// context of the call site that it will be inserted into.
 class CallerSideDefaultArgExprRequest

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -62,6 +62,8 @@ SWIFT_REQUEST(TypeChecker, DefaultArgumentExprRequest,
               Expr *(ParamDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultArgumentTypeRequest,
               Type(ParamDecl *), SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, DefaultArgumentIsolation,
+              ActorIsolation(ParamDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultArgumentInitContextRequest,
               Initializer *(ParamDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DefaultDefinitionTypeRequest,

include/swift/Basic/Features.def

@@ -222,6 +222,9 @@ EXPERIMENTAL_FEATURE(SendNonSendable, false)
 /// Within strict concurrency, narrow global variable isolation requirements.
 EXPERIMENTAL_FEATURE(GlobalConcurrency, false)
 
+/// Allow default arguments to require isolation at the call-site.
+EXPERIMENTAL_FEATURE(IsolatedDefaultArguments, false)
+
 /// Enable extended callbacks (with additional parameters) to be used when the
 /// "playground transform" is enabled.
 EXPERIMENTAL_FEATURE(PlaygroundExtendedCallbacks, true)

lib/AST/ASTPrinter.cpp

@@ -3551,6 +3551,10 @@ static bool usesFeatureSendNonSendable(Decl *decl) {
 
 static bool usesFeatureGlobalConcurrency(Decl *decl) { return false; }
 
+static bool usesFeatureIsolatedDefaultArguments(Decl *decl) {
+  return false;
+}
+
 static bool usesFeaturePlaygroundExtendedCallbacks(Decl *decl) {
   return false;
 }

lib/AST/Decl.cpp

@@ -8263,6 +8263,14 @@ Type ParamDecl::getTypeOfDefaultExpr() const {
   return Type();
 }
 
+ActorIsolation ParamDecl::getDefaultArgumentIsolation() const {
+  auto &ctx = getASTContext();
+  return evaluateOrDefault(
+      ctx.evaluator,
+      DefaultArgumentIsolation{const_cast<ParamDecl *>(this)},
+      ActorIsolation::forNonisolated());
+}
+
 void ParamDecl::setDefaultExpr(Expr *E, bool isTypeChecked) {
   if (!DefaultValueAndFlags.getPointer()) {
     if (!E) return;

lib/AST/Expr.cpp

@@ -1606,6 +1606,12 @@ Expr *DefaultArgumentExpr::getCallerSideDefaultExpr() const {
                            new (ctx) ErrorExpr(getSourceRange(), getType()));
 }
 
+ActorIsolation
+DefaultArgumentExpr::getRequiredIsolation() const {
+  auto *param = getParamDecl();
+  return param->getDefaultArgumentIsolation();
+}
+
 ValueDecl *ApplyExpr::getCalledValue(bool skipFunctionConversions) const {
   return ::getCalledValue(Fn, skipFunctionConversions);
 }

lib/Sema/TypeCheckConcurrency.cpp

@@ -1939,6 +1939,12 @@ namespace {
     llvm::function_ref<ActorIsolation(AbstractClosureExpr *)>
         getClosureActorIsolation;
 
+    bool shouldRefineIsolation = false;
+
+    /// Used under the mode to compute required actor isolation for
+    /// an expression or function.
+    ActorIsolation requiredIsolation = ActorIsolation::forNonisolated();
+
     /// Keeps track of the capture context of variables that have been
     /// explicitly captured in closures.
     llvm::SmallDenseMap<VarDecl *, TinyPtrVector<const DeclContext *>>
@@ -2123,6 +2129,65 @@ namespace {
       }
     }
 
+    bool refineRequiredIsolation(ActorIsolation refinedIsolation) {
+      if (!shouldRefineIsolation)
+        return false;
+
+      if (auto *closure = dyn_cast<AbstractClosureExpr>(getDeclContext())) {
+        // We cannot infer a more specific actor isolation for a @Sendable
+        // closure. It is an error to cast away actor isolation from a function
+        // type, but this is okay for non-Sendable closures because they cannot
+        // leave the isolation domain they're created in anyway.
+        if (closure->isSendable())
+          return false;
+
+        if (closure->getActorIsolation().isActorIsolated())
+          return false;
+      }
+
+      // To refine the required isolation, the existing requirement
+      // must either be 'nonisolated' or exactly the same as the
+      // new refinement.
+      if (requiredIsolation == ActorIsolation::Nonisolated ||
+          requiredIsolation == refinedIsolation) {
+        requiredIsolation = refinedIsolation;
+        return true;
+      }
+
+      return false;
+    }
+
+    void checkDefaultArgument(DefaultArgumentExpr *expr) {
+      // Check the context isolation against the required isolation for
+      // evaluating the default argument synchronously. If the default
+      // argument must be evaluated asynchronously, it must be written
+      // explicitly in the argument list with 'await'.
+      auto requiredIsolation = expr->getRequiredIsolation();
+      auto contextIsolation = getInnermostIsolatedContext(
+          getDeclContext(), getClosureActorIsolation);
+
+      if (requiredIsolation == contextIsolation)
+        return;
+
+      switch (requiredIsolation) {
+      // Nonisolated is okay from any caller isolation because
+      // default arguments cannot have any async calls.
+      case ActorIsolation::Unspecified:
+      case ActorIsolation::Nonisolated:
+        return;
+
+      case ActorIsolation::GlobalActor:
+      case ActorIsolation::GlobalActorUnsafe:
+      case ActorIsolation::ActorInstance:
+        break;
+      }
+
+      auto &ctx = getDeclContext()->getASTContext();
+      ctx.Diags.diagnose(
+          expr->getLoc(), diag::isolated_default_argument,
+          requiredIsolation, contextIsolation);
+    }
+
     /// Check closure captures for Sendable violations.
     void checkLocalCaptures(AnyFunctionRef localFunc) {
       SmallVector<CapturedValue, 2> captures;
@@ -2180,6 +2245,16 @@ namespace {
       contextStack.push_back(dc);
     }
 
+    ActorIsolation computeRequiredIsolation(Expr *expr) {
+      auto &ctx = getDeclContext()->getASTContext();
+
+      shouldRefineIsolation =
+          ctx.LangOpts.hasFeature(Feature::IsolatedDefaultArguments);
+      expr->walk(*this);
+      shouldRefineIsolation = false;
+      return requiredIsolation;
+    }
+
     /// Searches the applyStack from back to front for the inner-most CallExpr
     /// and marks that CallExpr as implicitly async.
     ///
@@ -2375,6 +2450,10 @@ namespace {
         checkFunctionConversion(funcConv);
       }
 
+      if (auto *defaultArg = dyn_cast<DefaultArgumentExpr>(expr)) {
+        checkDefaultArgument(defaultArg);
+      }
+
       return Action::Continue(expr);
     }
 
@@ -2920,6 +2999,9 @@ namespace {
       if (!unsatisfiedIsolation)
         return false;
 
+      if (refineRequiredIsolation(*unsatisfiedIsolation))
+        return false;
+
       // At this point, we know a jump is made to the callee that yields
       // an isolation requirement unsatisfied by the calling context, so
       // set the unsatisfiedIsolationJump fields of the ApplyExpr appropriately
@@ -3255,6 +3337,14 @@ namespace {
 
       case AsyncMarkingResult::SyncContext:
       case AsyncMarkingResult::NotFound:
+        // If we found an implicitly async reference in a sync
+        // context and we're computing the required isolation for
+        // an expression, the calling context requires the isolation
+        // of the reference.
+        if (refineRequiredIsolation(result.isolation)) {
+          return false;
+        }
+
         // Complain about access outside of the isolation domain.
         auto useKind = static_cast<unsigned>(
             kindOfUsage(decl, context).value_or(VarRefUseEnv::Read));
@@ -3467,6 +3557,12 @@ void swift::checkInitializerActorIsolation(Initializer *init, Expr *expr) {
   expr->walk(checker);
 }
 
+ActorIsolation 
+swift::computeRequiredIsolation(Initializer *init, Expr *expr) {
+  ActorIsolationChecker checker(init);
+  return checker.computeRequiredIsolation(expr);
+}
+
 void swift::checkEnumElementActorIsolation(
     EnumElementDecl *element, Expr *expr) {
   ActorIsolationChecker checker(element);

lib/Sema/TypeCheckConcurrency.h

@@ -60,6 +60,10 @@ void checkInitializerActorIsolation(Initializer *init, Expr *expr);
 void checkEnumElementActorIsolation(EnumElementDecl *element, Expr *expr);
 void checkPropertyWrapperActorIsolation(VarDecl *wrappedVar, Expr *expr);
 
+/// Compute the actor isolation required in order to evaluate the given
+/// initializer expression synchronously.
+ActorIsolation computeRequiredIsolation(Initializer *init, Expr *expr);
+
 /// States the reason for checking the Sendability of a given declaration.
 enum class SendableCheckReason {
   /// A reference to an actor from outside that actor.

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1069,6 +1069,8 @@ static void checkDefaultArguments(ParameterList *params) {
   for (auto *param : *params) {
     auto ifacety = param->getInterfaceType();
     auto *expr = param->getTypeCheckedDefaultExpr();
+    (void)param->getDefaultArgumentIsolation();
+
     if (!ifacety->hasPlaceholder()) {
       continue;
     }
@@ -1149,13 +1151,22 @@ Expr *DefaultArgumentExprRequest::evaluate(Evaluator &evaluator,
   // Walk the checked initializer and contextualize any closures
   // we saw there.
   TypeChecker::contextualizeInitializer(dc, initExpr);
-
-  checkInitializerActorIsolation(dc, initExpr);
   TypeChecker::checkInitializerEffects(dc, initExpr);
 
   return initExpr;
 }
 
+ActorIsolation 
+DefaultArgumentIsolation::evaluate(Evaluator &evaluator,
+                                   ParamDecl *param) const {
+  if (!param->hasDefaultExpr())
+    return ActorIsolation::forUnspecified();
+
+  auto *dc = param->getDefaultArgumentInitContext();
+  auto *initExpr = param->getTypeCheckedDefaultExpr();
+  return computeRequiredIsolation(dc, initExpr);
+}
+
 Type DefaultArgumentTypeRequest::evaluate(Evaluator &evaluator,
                                           ParamDecl *param) const {
   if (auto *expr = param->getTypeCheckedDefaultExpr()) {