[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.");
@@ -2022,9 +2023,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

@@ -2259,6 +2259,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.

lib/Sema/TypeCheckConcurrency.cpp

@@ -2321,7 +2321,7 @@ namespace {
           if (auto lookupExpr = dyn_cast_or_null<LookupExpr>(context)) {
             if (auto memberRef = dyn_cast<MemberRefExpr>(lookupExpr)) {
               memberRef->setImplicitlyThrows(true);
-              memberRef->setShouldApplyLookupDistributedThunk(true);
+              memberRef->setAccessViaDistributedThunk();
             } else {
               llvm_unreachable("expected distributed prop to be a MemberRef");
             }