implementation of async actor properties in SILGen

The strategy for implementing them is integrated with the
PathComponent infrastructure in SILGen in order to correctly
support mixtures of chained accesses and forced optionals, etc.

The actor isolation information is only piped into LValues from
the expressions that might be marked implicitly-async.

Author: kavon

lib/SILGen/LValue.h

@@ -209,10 +209,16 @@ class PhysicalPathComponent : public PathComponent {
   virtual void _anchor() override;
 
 protected:
-  PhysicalPathComponent(LValueTypeData typeData, KindTy Kind)
-    : PathComponent(typeData, Kind) {
+  Optional<ActorIsolation> ActorIso;
+  PhysicalPathComponent(LValueTypeData typeData, KindTy Kind,
+                        Optional<ActorIsolation> actorIso = None)
+    : PathComponent(typeData, Kind), ActorIso(actorIso) {
     assert(isPhysical() && "PhysicalPathComponent Kind isn't physical");
   }
+
+public:
+  // Obtains the actor-isolation required for any loads of this component.
+  Optional<ActorIsolation> getActorIsolation() const { return ActorIso; }
 };
 
 inline PhysicalPathComponent &PathComponent::asPhysical() {
@@ -421,12 +427,19 @@ class LValue {
     Path.emplace_back(new T(std::forward<As>(args)...));
   }
 
+  // NOTE: Optional<ActorIsolation> inside of LValues
+  // Some path components carry an ActorIsolation value, which is an indicator
+  // that the access to that component must be performed by switching to the
+  // given actor's isolation domain. If the indicator is not present, that
+  // only means that a switch does not need to be emitted during the access.
+
   void addNonMemberVarComponent(SILGenFunction &SGF, SILLocation loc,
                                 VarDecl *var, SubstitutionMap subs,
                                 LValueOptions options,
                                 SGFAccessKind accessKind,
                                 AccessStrategy strategy,
-                                CanType formalRValueType);
+                                CanType formalRValueType,
+                                Optional<ActorIsolation> actorIso = None);
 
   /// Add a member component to the access path of this lvalue.
   void addMemberComponent(SILGenFunction &SGF, SILLocation loc,
@@ -448,7 +461,8 @@ class LValue {
                              SGFAccessKind accessKind,
                              AccessStrategy accessStrategy,
                              CanType formalRValueType,
-                             bool isOnSelf = false);
+                             bool isOnSelf = false,
+                             Optional<ActorIsolation> actorIso = None);
 
   void addMemberSubscriptComponent(SILGenFunction &SGF, SILLocation loc,
                                    SubscriptDecl *subscript,
@@ -460,7 +474,8 @@ class LValue {
                                    CanType formalRValueType,
                                    PreparedArguments &&indices,
                                    Expr *indexExprForDiagnostics,
-                                   bool isOnSelfParameter = false);
+                                   bool isOnSelfParameter = false,
+                                   Optional<ActorIsolation> actorIso = None);
 
   /// Add a subst-to-orig reabstraction component.  That is, given
   /// that this l-value trafficks in values following the substituted

lib/SILGen/SILGenApply.cpp

@@ -4285,30 +4285,6 @@ bool SILGenModule::isNonMutatingSelfIndirect(SILDeclRef methodRef) {
   return self.isFormalIndirect();
 }
 
-Optional<SILValue> SILGenFunction::emitLoadActorExecutorForCallee(
-                                                  ValueDecl *calleeVD,
-                                                  ArrayRef<ManagedValue> args) {
-  if (auto *funcDecl = dyn_cast_or_null<AbstractFunctionDecl>(calleeVD)) {
-    auto actorIso = getActorIsolation(funcDecl);
-    switch (actorIso.getKind()) {
-      case ActorIsolation::Unspecified:
-      case ActorIsolation::Independent:
-      case ActorIsolation::IndependentUnsafe:
-        break;
-
-      case ActorIsolation::ActorInstance: {
-        assert(args.size() > 0 && "no self argument for actor-instance call?");
-        auto calleeSelf = args.back();
-        return calleeSelf.borrow(*this, F.getLocation()).getValue();
-      }
-
-      case ActorIsolation::GlobalActor:
-      case ActorIsolation::GlobalActorUnsafe:
-        return emitLoadGlobalActorExecutor(actorIso.getGlobalActor());
-    }
-  }
-  return None;
-}
 
 //===----------------------------------------------------------------------===//
 //                           Top Level Entrypoints
@@ -4418,10 +4394,16 @@ RValue SILGenFunction::emitApply(ResultPlanPtr &&resultPlan,
     assert(F.isAsync() && "cannot hop_to_executor in a non-async func!");
 
     auto calleeVD = implicitlyAsyncApply.getValue();
-    auto maybeExecutor = emitLoadActorExecutorForCallee(calleeVD, args);
+    if (auto *funcDecl = dyn_cast_or_null<AbstractFunctionDecl>(calleeVD)) {
+      Optional<ManagedValue> actorSelf;
 
-    assert(maybeExecutor.hasValue());
-    B.createHopToExecutor(loc, maybeExecutor.getValue());
+      if (args.size() > 0)
+        actorSelf = args.back();
+
+      auto didHop = emitHopToTargetActor(loc, getActorIsolation(funcDecl),
+                                         actorSelf);
+      assert(didHop);
+    }
   }
 
   SILValue rawDirectResult;

lib/SILGen/SILGenExpr.cpp

@@ -927,7 +927,6 @@ emitRValueForDecl(SILLocation loc, ConcreteDeclRef declRef, Type ncRefType,
 }
 
 RValue RValueEmitter::visitDeclRefExpr(DeclRefExpr *E, SGFContext C) {
-  assert(!E->isImplicitlyAsync() && "TODO: Implement SILGen lowering");
   return SGF.emitRValueForDecl(E, E->getDeclRef(), E->getType(),
                                E->getAccessSemantics(), C);
 }
@@ -2183,7 +2182,6 @@ RValue RValueEmitter::visitMemberRefExpr(MemberRefExpr *e,
   assert(!e->getType()->is<LValueType>() &&
          "RValueEmitter shouldn't be called on lvalues");
   assert(isa<VarDecl>(e->getMember().getDecl()));
-  assert(!e->isImplicitlyAsync() && "TODO: Implement SILGen lowering");
 
   // Everything else should use the l-value logic.
 
@@ -2211,7 +2209,6 @@ visitDotSyntaxBaseIgnoredExpr(DotSyntaxBaseIgnoredExpr *E, SGFContext C) {
 }
 
 RValue RValueEmitter::visitSubscriptExpr(SubscriptExpr *E, SGFContext C) {
-  assert(!E->isImplicitlyAsync() && "TODO: Implement SILGen lowering");
   // Any writebacks for this access are tightly scoped.
   FormalEvaluationScope scope(SGF);
 

lib/SILGen/SILGenFunction.h

@@ -857,12 +857,13 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   // Concurrency
   //===--------------------------------------------------------------------===//
 
-  /// Generates code to obtain the callee function's executor, if the function
-  /// is actor-isolated.
+  /// Generates code to obtain the executor for the given actor isolation,
+  /// as-needed, and emits a \c hop_to_executor to that executor.
   ///
-  /// \returns a SILValue representing the executor, if an executor exists.
-  Optional<SILValue> emitLoadActorExecutorForCallee(ValueDecl *calleeVD,
-                                                    ArrayRef<ManagedValue> args);
+  /// \returns a non-null pointer if a \c hop_to_executor was emitted.
+  HopToExecutorInst* emitHopToTargetActor(SILLocation loc,
+                            Optional<ActorIsolation> actorIso,
+                            Optional<ManagedValue> actorSelf);
 
   /// Generates code to obtain the executor given the actor's decl.
   /// \returns a SILValue representing the executor.