Emit actor hop as part of call to the getter.

When emitting a call to the getter for storage, emit the actor hop (and
hop back) as part of the call itself, rather than around the whole
initialization. This address a bug involving initialization with an
optional binding in an `if let`, where the hop-back would only be
performed on the non-nil branch.

Fixes rdar://96487805 / FB10562197

Author: DougGregor

lib/SILGen/SILGenApply.cpp

@@ -5805,13 +5805,15 @@ SILDeclRef SILGenModule::getAccessorDeclRef(AccessorDecl *accessor) {
 }
 
 /// Emit a call to a getter.
-RValue SILGenFunction::emitGetAccessor(SILLocation loc, SILDeclRef get,
-                                       SubstitutionMap substitutions,
-                                       ArgumentSource &&selfValue, bool isSuper,
-                                       bool isDirectUse,
-                                       PreparedArguments &&subscriptIndices,
-                                       SGFContext c,
-                                       bool isOnSelfParameter) {
+RValue SILGenFunction::emitGetAccessor(
+    SILLocation loc, SILDeclRef get,
+    SubstitutionMap substitutions,
+    ArgumentSource &&selfValue, bool isSuper,
+    bool isDirectUse,
+    PreparedArguments &&subscriptIndices,
+    SGFContext c,
+    bool isOnSelfParameter,
+    Optional<ImplicitActorHopTarget> implicitActorHopTarget) {
   // Scope any further writeback just within this operation.
   FormalEvaluationScope writebackScope(*this);
 
@@ -5822,6 +5824,9 @@ RValue SILGenFunction::emitGetAccessor(SILLocation loc, SILDeclRef get,
   CanAnyFunctionType accessType = getter.getSubstFormalType();
 
   CallEmission emission(*this, std::move(getter), std::move(writebackScope));
+  if (implicitActorHopTarget)
+    emission.setImplicitlyAsync(implicitActorHopTarget);
+
   // Self ->
   if (hasSelf) {
     emission.addSelfParam(loc, std::move(selfValue),

lib/SILGen/SILGenFunction.h

@@ -1440,12 +1440,14 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                         CanType baseFormalType,
                                         SILDeclRef accessor);
 
-  RValue emitGetAccessor(SILLocation loc, SILDeclRef getter,
-                         SubstitutionMap substitutions,
-                         ArgumentSource &&optionalSelfValue, bool isSuper,
-                         bool isDirectAccessorUse,
-                         PreparedArguments &&optionalSubscripts, SGFContext C,
-                         bool isOnSelfParameter);
+  RValue emitGetAccessor(
+      SILLocation loc, SILDeclRef getter,
+      SubstitutionMap substitutions,
+      ArgumentSource &&optionalSelfValue, bool isSuper,
+      bool isDirectAccessorUse,
+      PreparedArguments &&optionalSubscripts, SGFContext C,
+      bool isOnSelfParameter,
+      Optional<ImplicitActorHopTarget> implicitActorHopTarget = None);
 
   void emitSetAccessor(SILLocation loc, SILDeclRef setter,
                        SubstitutionMap substitutions,

lib/SILGen/SILGenLValue.cpp

@@ -1641,26 +1641,26 @@ namespace {
       assert(getAccessorDecl()->isGetter());
 
       SILDeclRef getter = Accessor;
-      ExecutorBreadcrumb prevExecutor;
       RValue rvalue;
-      {
-        FormalEvaluationScope scope(SGF);
-
-        // If the 'get' is in the context of the target's actor, do a hop first.
-        prevExecutor = SGF.emitHopToTargetActor(loc, ActorIso, base);
-
-        auto args =
-            std::move(*this).prepareAccessorArgs(SGF, loc, base, getter);
+      FormalEvaluationScope scope(SGF);
 
-        rvalue = SGF.emitGetAccessor(
-            loc, getter, Substitutions, std::move(args.base), IsSuper,
-            IsDirectAccessorUse, std::move(args.Indices), c,
-            IsOnSelfParameter);
+      // FIXME: This somewhat silly, because the original expression should
+      // already have one of these.
+      Optional<ImplicitActorHopTarget> implicitActorHopTarget;
+      if (ActorIso) {
+        implicitActorHopTarget = ActorIso->isGlobalActor()
+            ? ImplicitActorHopTarget::forGlobalActor(
+              ActorIso->getGlobalActor())
+            : ImplicitActorHopTarget::forInstanceSelf();
+      }
 
-      } // End the evaluation scope before any hop back to the current executor.
+      auto args =
+          std::move(*this).prepareAccessorArgs(SGF, loc, base, getter);
 
-      // If we hopped to the target's executor, then we need to hop back.
-      prevExecutor.emit(SGF, loc);
+      rvalue = SGF.emitGetAccessor(
+          loc, getter, Substitutions, std::move(args.base), IsSuper,
+          IsDirectAccessorUse, std::move(args.Indices), c,
+          IsOnSelfParameter, implicitActorHopTarget);
 
       return rvalue;
     }