Merge pull request swiftlang#38549 from DougGregor/isolated-param-actor-hops-5.5

Author: DougGregor

CHANGELOG.md

@@ -29,6 +29,31 @@ CHANGELOG
 Swift 5.5
 ---------
 
+* [SE-0313][]:
+
+  Parameters of actor type can be declared as `isolated`, which means that they
+  represent the actor on which that code will be executed. `isolated` parameters
+  extend the actor-isolated semantics of the `self` parameter of actor methods
+  to arbitrary parameters. For example:
+
+  ```swift
+  actor MyActor {
+    func f() { }
+  }
+
+  func g(actor: isolated MyActor) {
+    actor.f()   // okay, this code is always executing on "actor"
+  }
+
+  func h(actor: MyActor) async {
+    g(actor: actor)        // error, call must be asynchronous
+    await g(actor: actor)  // okay, hops to "actor" before calling g
+  }
+  ```
+
+  The `self` parameter of actor methods are implicitly `isolated`. The
+  `nonisolated` keyword makes the `self` parameter no longer `isolated`.
+
 * [SR-14731][]:
 
   The compiler now correctly rejects the application of generic arguments to the

include/swift/AST/Expr.h

@@ -1186,11 +1186,74 @@ class DiscardAssignmentExpr : public Expr {
   }
 };
 
+/// Describes the actor to which an implicit-async expression will hop.
+struct ImplicitActorHopTarget {
+  enum Kind {
+    /// The "self" instance.
+    InstanceSelf,
+    /// A global actor with the given type.
+    GlobalActor,
+    /// An isolated parameter in a call.
+    IsolatedParameter,
+  };
+
+private:
+  /// The lower two bits are the Kind, and the remaining bits are used for
+  /// the payload, which might by a TypeBase * (for a global actor) or a
+  /// integer value (for an isolated parameter).
+  uintptr_t bits;
+
+  constexpr ImplicitActorHopTarget(uintptr_t bits) : bits(bits) { }
+
+public:
+  /// Default-initialized to instance "self".
+  constexpr ImplicitActorHopTarget() : bits(0) { }
+
+  static ImplicitActorHopTarget forInstanceSelf() {
+    return ImplicitActorHopTarget(InstanceSelf);
+  }
+
+  static ImplicitActorHopTarget forGlobalActor(Type globalActor) {
+    uintptr_t bits =
+      reinterpret_cast<uintptr_t>(globalActor.getPointer()) | GlobalActor;
+    return ImplicitActorHopTarget(bits);
+  }
+
+  static ImplicitActorHopTarget forIsolatedParameter(unsigned index) {
+    uintptr_t bits = static_cast<uintptr_t>(index) << 2 | IsolatedParameter;
+    return ImplicitActorHopTarget(bits);
+  }
+
+  /// Determine the kind of implicit actor hop being performed.
+  Kind getKind() const {
+    return static_cast<Kind>(bits & 0x03);
+  }
+
+  operator Kind() const {
+    return getKind();
+  }
+
+  /// Retrieve the global actor type for an implicit hop to a global actor.
+  Type getGlobalActor() const {
+    assert(getKind() == GlobalActor);
+    return Type(reinterpret_cast<TypeBase *>(bits & ~0x03));
+  }
+
+  /// Retrieve the (zero-based) parameter index for the isolated parameter
+  /// in a call.
+  unsigned getIsolatedParameterIndex() const {
+    assert(getKind() == IsolatedParameter);
+    return bits >> 2;
+  }
+};
+
+
 /// DeclRefExpr - A reference to a value, "x".
 class DeclRefExpr : public Expr {
   /// The declaration pointer.
   ConcreteDeclRef D;
   DeclNameLoc Loc;
+  ImplicitActorHopTarget implicitActorHopTarget;
 
 public:
   DeclRefExpr(ConcreteDeclRef D, DeclNameLoc Loc, bool Implicit,
@@ -1216,13 +1279,18 @@ class DeclRefExpr : public Expr {
   }
 
   /// Determine whether this reference needs to happen asynchronously, i.e.,
-  /// guarded by hop_to_executor
-  bool isImplicitlyAsync() const { return Bits.DeclRefExpr.IsImplicitlyAsync; }
+  /// guarded by hop_to_executor, and if so describe the target.
+  Optional<ImplicitActorHopTarget> isImplicitlyAsync() const {
+    if (!Bits.DeclRefExpr.IsImplicitlyAsync)
+      return None;
+
+    return implicitActorHopTarget;
+  }
 
-  /// Set whether this reference needs to happen asynchronously, i.e.,
-  /// guarded by hop_to_executor
-  void setImplicitlyAsync(bool isImplicitlyAsync) {
-    Bits.DeclRefExpr.IsImplicitlyAsync = isImplicitlyAsync;
+  /// Note that this reference is implicitly async and set the target.
+  void setImplicitlyAsync(ImplicitActorHopTarget target) {
+    Bits.DeclRefExpr.IsImplicitlyAsync = true;
+    implicitActorHopTarget = target;
   }
 
   /// Retrieve the concrete declaration reference.
@@ -1534,6 +1602,7 @@ class UnresolvedDeclRefExpr : public Expr {
 class LookupExpr : public Expr {
   Expr *Base;
   ConcreteDeclRef Member;
+  ImplicitActorHopTarget implicitActorHopTarget;
 
 protected:
   explicit LookupExpr(ExprKind Kind, Expr *base, ConcreteDeclRef member,
@@ -1556,7 +1625,7 @@ class LookupExpr : public Expr {
 
   /// Determine whether the operation has a known underlying declaration or not.
   bool hasDecl() const { return static_cast<bool>(Member); }
-  
+
   /// Retrieve the declaration that this /// operation refers to.
   /// Only valid when \c hasDecl() is true.
   ConcreteDeclRef getDecl() const {
@@ -1571,13 +1640,18 @@ class LookupExpr : public Expr {
   void setIsSuper(bool isSuper) { Bits.LookupExpr.IsSuper = isSuper; }
 
   /// Determine whether this reference needs to happen asynchronously, i.e.,
-  /// guarded by hop_to_executor
-  bool isImplicitlyAsync() const { return Bits.LookupExpr.IsImplicitlyAsync; }
+  /// guarded by hop_to_executor, and if so describe the target.
+  Optional<ImplicitActorHopTarget> isImplicitlyAsync() const {
+    if (!Bits.LookupExpr.IsImplicitlyAsync)
+      return None;
+
+    return implicitActorHopTarget;
+  }
 
-  /// Set whether this reference needs to happen asynchronously, i.e.,
-  /// guarded by hop_to_executor
-  void setImplicitlyAsync(bool isImplicitlyAsync) {
-    Bits.LookupExpr.IsImplicitlyAsync = isImplicitlyAsync;
+  /// Note that this reference is implicitly async and set the target.
+  void setImplicitlyAsync(ImplicitActorHopTarget target) {
+    Bits.LookupExpr.IsImplicitlyAsync = true;
+    implicitActorHopTarget = target;
   }
 
   static bool classof(const Expr *E) {
@@ -4446,7 +4520,9 @@ class ApplyExpr : public Expr {
 
   /// The argument being passed to it, and whether it's a 'super' argument.
   llvm::PointerIntPair<Expr *, 1, bool> ArgAndIsSuper;
-  
+
+  ImplicitActorHopTarget implicitActorHopTarget;
+
   /// Returns true if \c e could be used as the call's argument. For most \c ApplyExpr
   /// subclasses, this means it is a \c ParenExpr or \c TupleExpr.
   bool validateArg(Expr *e) const;
@@ -4523,11 +4599,19 @@ class ApplyExpr : public Expr {
   ///
   /// where the new closure is declared to be async.
   ///
-  bool implicitlyAsync() const {
-    return Bits.ApplyExpr.ImplicitlyAsync;
+  /// When the application is implciitly async, the result describes
+  /// the actor to which we need to need to hop.
+  Optional<ImplicitActorHopTarget> isImplicitlyAsync() const {
+    if (!Bits.ApplyExpr.ImplicitlyAsync)
+      return None;
+
+    return implicitActorHopTarget;
   }
-  void setImplicitlyAsync(bool flag) {
-    Bits.ApplyExpr.ImplicitlyAsync = flag;
+
+  /// Note that this application is implicitly async and set the target.
+  void setImplicitlyAsync(ImplicitActorHopTarget target) {
+    Bits.ApplyExpr.ImplicitlyAsync = true;
+    implicitActorHopTarget = target;
   }
 
   ValueDecl *getCalledValue() const;

lib/SILGen/SILGenApply.cpp

@@ -3651,15 +3651,15 @@ class CallEmission {
 
   Callee callee;
   FormalEvaluationScope initialWritebackScope;
-  Optional<ActorIsolation> implicitAsyncIsolation;
+  Optional<ImplicitActorHopTarget> implicitActorHopTarget;
 
 public:
   /// Create an emission for a call of the given callee.
   CallEmission(SILGenFunction &SGF, Callee &&callee,
                FormalEvaluationScope &&writebackScope)
       : SGF(SGF), callee(std::move(callee)),
         initialWritebackScope(std::move(writebackScope)),
-        implicitAsyncIsolation(None) {}
+        implicitActorHopTarget(None) {}
 
   /// A factory method for decomposing the apply expr \p e into a call
   /// emission.
@@ -3699,8 +3699,9 @@ class CallEmission {
   /// Sets a flag that indicates whether this call be treated as being 
   /// implicitly async, i.e., it requires a hop_to_executor prior to 
   /// invoking the sync callee, etc.
-  void setImplicitlyAsync(Optional<ActorIsolation> implicitAsyncIsolation) {
-    this->implicitAsyncIsolation = implicitAsyncIsolation;
+  void setImplicitlyAsync(
+      Optional<ImplicitActorHopTarget> implicitActorHopTarget) {
+    this->implicitActorHopTarget = implicitActorHopTarget;
   }
 
   CleanupHandle applyCoroutine(SmallVectorImpl<ManagedValue> &yields);
@@ -3926,7 +3927,7 @@ RValue CallEmission::applyNormalCall(SGFContext C) {
   return SGF.emitApply(
       std::move(resultPlan), std::move(argScope), uncurriedLoc.getValue(), mv,
       callee.getSubstitutions(), uncurriedArgs, calleeTypeInfo, options,
-      uncurriedContext, implicitAsyncIsolation);
+      uncurriedContext, implicitActorHopTarget);
 }
 
 static void emitPseudoFunctionArguments(SILGenFunction &SGF,
@@ -4241,28 +4242,9 @@ CallEmission CallEmission::forApplyExpr(SILGenFunction &SGF, ApplyExpr *e) {
                          apply.callSite->isNoThrows(),
                          apply.callSite->isNoAsync());
 
-    // For an implicitly-async call, determine the actor isolation.
-    if (apply.callSite->implicitlyAsync()) {
-      Optional<ActorIsolation> isolation;
-
-      // Check for global-actor isolation on the function type.
-      if (auto fnType = apply.callSite->getFn()->getType()
-              ->castTo<FunctionType>()) {
-        if (Type globalActor = fnType->getGlobalActor()) {
-          isolation = ActorIsolation::forGlobalActor(globalActor, false);
-        }
-      }
-
-      // If there was no global-actor isolation on the function type, find
-      // the callee declaration and retrieve the isolation from it.
-      if (!isolation) {
-        if (auto decl = emission.callee.getDecl())
-          isolation = getActorIsolation(decl);
-      }
-
-      assert(isolation && "Implicitly asynchronous call without isolation");
-      emission.setImplicitlyAsync(isolation);
-    }
+    // For an implicitly-async call, record the target of the actor hop.
+    if (auto target = apply.callSite->isImplicitlyAsync())
+      emission.setImplicitlyAsync(target);
   }
 
   return emission;
@@ -4315,13 +4297,14 @@ bool SILGenModule::isNonMutatingSelfIndirect(SILDeclRef methodRef) {
 /// lowered appropriately for the abstraction level but that the
 /// result does need to be turned back into something matching a
 /// formal type.
-RValue SILGenFunction::emitApply(ResultPlanPtr &&resultPlan,
-                                 ArgumentScope &&argScope, SILLocation loc,
-                                 ManagedValue fn, SubstitutionMap subs,
-                                 ArrayRef<ManagedValue> args,
-                                 const CalleeTypeInfo &calleeTypeInfo,
-                                 ApplyOptions options, SGFContext evalContext,
-                                 Optional<ActorIsolation> implicitAsyncIsolation) {
+RValue SILGenFunction::emitApply(
+    ResultPlanPtr &&resultPlan,
+    ArgumentScope &&argScope, SILLocation loc,
+    ManagedValue fn, SubstitutionMap subs,
+    ArrayRef<ManagedValue> args,
+    const CalleeTypeInfo &calleeTypeInfo,
+    ApplyOptions options, SGFContext evalContext,
+    Optional<ImplicitActorHopTarget> implicitActorHopTarget) {
   auto substFnType = calleeTypeInfo.substFnType;
   auto substResultType = calleeTypeInfo.substResultType;
 
@@ -4409,28 +4392,31 @@ RValue SILGenFunction::emitApply(ResultPlanPtr &&resultPlan,
 
   ExecutorBreadcrumb breadcrumb;
 
-  // The presence of `implicitAsyncIsolation` indicates that the callee is a
+  // The presence of `implicitActorHopTarget` indicates that the callee is a
   // synchronous function isolated to an actor other than our own.
   // Such functions require the caller to hop to the callee's executor
   // prior to invoking the callee.
-  if (implicitAsyncIsolation) {
+  if (implicitActorHopTarget) {
     assert(F.isAsync() && "cannot hop_to_executor in a non-async func!");
 
-    switch (*implicitAsyncIsolation) {
-    case ActorIsolation::ActorInstance:
-      breadcrumb = emitHopToTargetActor(loc, *implicitAsyncIsolation,
-                                        args.back());
+    SILValue executor;
+    switch (*implicitActorHopTarget) {
+    case ImplicitActorHopTarget::InstanceSelf:
+      executor = emitLoadActorExecutor(loc, args.back());
       break;
 
-    case ActorIsolation::GlobalActor:
-    case ActorIsolation::GlobalActorUnsafe:
-      breadcrumb = emitHopToTargetActor(loc, *implicitAsyncIsolation, None);
+    case ImplicitActorHopTarget::GlobalActor:
+      executor = emitLoadGlobalActorExecutor(
+          implicitActorHopTarget->getGlobalActor());
       break;
 
-    case ActorIsolation::Independent:
-    case ActorIsolation::Unspecified:
-      llvm_unreachable("Not actor-isolated");
+    case ImplicitActorHopTarget::IsolatedParameter:
+      executor = emitLoadActorExecutor(
+          loc, args[implicitActorHopTarget->getIsolatedParameterIndex()]);
+      break;
     }
+
+    breadcrumb = emitHopToTargetExecutor(loc, executor);
   } else if (ExpectedExecutor && substFnType->isAsync()) {
     // Otherwise, if we're in an actor method ourselves, and we're calling into
     // any sort of async function, we'll want to make sure to hop back to our

lib/SILGen/SILGenFunction.h

@@ -839,6 +839,15 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                             Optional<ActorIsolation> actorIso,
                             Optional<ManagedValue> actorSelf);
 
+  /// Emit a hop to the target executor, returning a breadcrumb with enough
+  /// enough information to hop back.
+  ExecutorBreadcrumb emitHopToTargetExecutor(SILLocation loc,
+                                             SILValue executor);
+
+  /// Generate a hop directly to a dynamic actor instance. This can only be done
+  /// inside an async actor-independent function. No hop-back is expected.
+  void emitHopToActorValue(SILLocation loc, ManagedValue actor);
+
   /// A version of `emitHopToTargetActor` that is specialized to the needs
   /// of various types of ConstructorDecls, like class or value initializers,
   /// because their prolog emission is not the same as for regular functions.
@@ -1589,7 +1598,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                    ArrayRef<ManagedValue> args,
                    const CalleeTypeInfo &calleeTypeInfo, ApplyOptions options,
                    SGFContext evalContext, 
-                   Optional<ActorIsolation> implicitAsyncIsolation);
+                   Optional<ImplicitActorHopTarget> implicitActorHopTarget);
 
   RValue emitApplyOfDefaultArgGenerator(SILLocation loc,
                                         ConcreteDeclRef defaultArgsOwner,