[AST] Add new member access semantics - DistributedThunk

`DistributedThunk` is to be used while accessing 'distributed'
computed property outside of its actor context.

Author: xedin

include/swift/AST/Expr.h

@@ -124,6 +124,12 @@ enum class AccessSemantics : uint8_t {
   /// This is an ordinary access to a declaration, using whatever
   /// polymorphism is expected.
   Ordinary,
+
+  /// This is an access to the underlying storage through a distributed thunk.
+  ///
+  /// The declaration must be a 'distributed' computed property used outside
+  /// of its actor isolation context.
+  DistributedThunk,
 };
 
 /// Expr - Base class for all expressions in swift.
@@ -155,11 +161,10 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
 
   SWIFT_INLINE_BITFIELD_EMPTY(LiteralExpr, Expr);
   SWIFT_INLINE_BITFIELD_EMPTY(IdentityExpr, Expr);
-  SWIFT_INLINE_BITFIELD(LookupExpr, Expr, 1+1+1+1,
+  SWIFT_INLINE_BITFIELD(LookupExpr, Expr, 1+1+1,
     IsSuper : 1,
     IsImplicitlyAsync : 1,
-    IsImplicitlyThrows : 1,
-    ShouldApplyDistributedThunk: 1
+    IsImplicitlyThrows : 1
   );
   SWIFT_INLINE_BITFIELD_EMPTY(DynamicLookupExpr, LookupExpr);
 
@@ -1656,18 +1661,6 @@ class LookupExpr : public Expr {
     Bits.LookupExpr.IsImplicitlyThrows = isImplicitlyThrows;
   }
 
-  /// Informs IRGen to that this expression should be applied as its distributed
-  /// thunk, rather than invoking the function directly.
-  ///
-  /// Only intended to be set on distributed get-only computed properties.
-  bool shouldApplyLookupDistributedThunk() const {
-    return Bits.LookupExpr.ShouldApplyDistributedThunk;
-  }
-
-  void setShouldApplyLookupDistributedThunk(bool flag) {
-    Bits.LookupExpr.ShouldApplyDistributedThunk = flag;
-  }
-
   static bool classof(const Expr *E) {
     return E->getKind() >= ExprKind::First_LookupExpr &&
            E->getKind() <= ExprKind::Last_LookupExpr;
@@ -1697,6 +1690,14 @@ class MemberRefExpr : public LookupExpr {
     return (AccessSemantics) Bits.MemberRefExpr.Semantics;
   }
 
+  /// Informs IRGen to that this member should be applied via its distributed
+  /// thunk, rather than invoking it directly.
+  ///
+  /// Only intended to be set on distributed get-only computed properties.
+  void setAccessViaDistributedThunk() {
+    Bits.MemberRefExpr.Semantics = (unsigned)AccessSemantics::DistributedThunk;
+  }
+
   SourceLoc getLoc() const { return NameLoc.getBaseNameLoc(); }
   SourceLoc getStartLoc() const {
     SourceLoc BaseStartLoc = getBase()->getStartLoc();

lib/AST/ASTDumper.cpp

@@ -255,6 +255,7 @@ static StringRef getAccessSemanticsString(AccessSemantics value) {
     case AccessSemantics::Ordinary: return "ordinary";
     case AccessSemantics::DirectToStorage: return "direct_to_storage";
     case AccessSemantics::DirectToImplementation: return "direct_to_impl";
+    case AccessSemantics::DistributedThunk: return "distributed_thunk";
   }
 
   llvm_unreachable("Unhandled AccessSemantics in switch.");
@@ -2035,9 +2036,6 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
 
   void visitMemberRefExpr(MemberRefExpr *E) {
     printCommon(E, "member_ref_expr");
-    if (E->shouldApplyLookupDistributedThunk()) {
-      OS << " distributed";
-    }
     PrintWithColorRAII(OS, DeclColor) << " decl=";
     printDeclRef(E->getMember());
     if (E->getAccessSemantics() != AccessSemantics::Ordinary)

lib/AST/Decl.cpp

@@ -2283,6 +2283,11 @@ AbstractStorageDecl::getAccessStrategy(AccessSemantics semantics,
     assert(hasStorage());
     return AccessStrategy::getStorage();
 
+  // FIXME: For now `DistributedThunk` behaves just like `Ordinary` but it
+  //        needs a new strategy to be useful.
+  case AccessSemantics::DistributedThunk:
+    LLVM_FALLTHROUGH;
+
   case AccessSemantics::Ordinary:
     // Skip these checks for local variables, both because they're unnecessary
     // and because we won't necessarily have computed access.
@@ -2295,14 +2300,6 @@ AbstractStorageDecl::getAccessStrategy(AccessSemantics semantics,
       if (shouldUseNativeDynamicDispatch())
         return getOpaqueAccessStrategy(this, accessKind, /*dispatch*/ false);
 
-//      if (auto var = dyn_cast<VarDecl>(this)) {
-//        if (var->isDistributed()) {
-//          fprintf(stderr, "[%s:%d] (%s) DIST STRATEGY!!\n", __FILE__, __LINE__, __FUNCTION__);
-//          var->dump();
-//          return getDirectToDistributedThunkAccessorStrategy(this);
-//        }
-//      }
-
       // If the storage is resilient from the given module and resilience
       // expansion, we cannot use direct access.
       //

lib/Sema/TypeCheckConcurrency.cpp

@@ -2363,27 +2363,20 @@ namespace {
       // is it an access to a property?
       if (isPropOrSubscript(decl)) {
         // Cannot reference properties or subscripts of distributed actors.
-        fprintf(stderr, "[%s:%d] (%s) prop\n", __FILE__, __LINE__, __FUNCTION__);
         if (isDistributed) {
-          fprintf(stderr, "[%s:%d] (%s) prop is dist\n", __FILE__, __LINE__, __FUNCTION__);
-
           bool setThrows = false;
           bool usesDistributedThunk = false;
           if (auto access = checkDistributedAccess(declLoc, decl, context)) {
             std::tie(setThrows, usesDistributedThunk) = *access;
           } else {
-            fprintf(stderr, "[%s:%d] (%s) prop is dist -> NOPE \n", __FILE__, __LINE__, __FUNCTION__);
             return AsyncMarkingResult::NotDistributed;
           }
 
           // distributed computed property access, mark it throws + async
           if (auto lookupExpr = dyn_cast_or_null<LookupExpr>(context)) {
             if (auto memberRef = dyn_cast<MemberRefExpr>(lookupExpr)) {
-              fprintf(stderr, "[%s:%d] (%s) SET DISTRIBUTED MEMBER REF\n", __FILE__, __LINE__, __FUNCTION__);
-              memberRef->dump();
-
               memberRef->setImplicitlyThrows(true);
-              memberRef->setShouldApplyLookupDistributedThunk(true);
+              memberRef->setAccessViaDistributedThunk();
             } else {
               llvm_unreachable("expected distributed prop to be a MemberRef");
             }