[Distributed] Generate thunk for accessor as a regular method

It used to be an accessor but that is not required because
SILDeclRef controls mangling which is the most imprortant
and could be used to emit the right reference.

Author: xedin

lib/AST/ASTMangler.cpp

@@ -3192,21 +3192,6 @@ void ASTMangler::appendEntity(const ValueDecl *decl) {
   // Handle accessors specially, they are mangled as modifiers on the accessed
   // declaration.
   if (auto accessor = dyn_cast<AccessorDecl>(decl)) {
-    // Distributed thunks associated with computed properties
-    // are currently implemented as accessors but they don't
-    // have to be and that could be changed in the future.
-    //
-    // Let's mangle them as `distributed func`s to make it easier
-    // to change implementation and because runtime needs a function
-    // type associated with the thunk to form a call to it.
-    if (accessor->isDistributedThunk()) {
-      appendContextOf(decl);
-      appendDeclName(accessor->getStorage());
-      appendDeclType(accessor, FunctionMangling);
-      appendOperator("F");
-      return;
-    }
-
     return appendAccessorEntity(
         getCodeForAccessorKind(accessor->getAccessorKind()),
         accessor->getStorage(), accessor->isStatic());
@@ -3506,5 +3491,28 @@ std::string ASTMangler::mangleDistributedThunk(const AbstractFunctionDecl *thunk
   // in recording them for distributed thunks.
   llvm::SaveAndRestore<bool> savedAllowMarkerProtocols(AllowMarkerProtocols,
                                                        false);
+
+  // Since computed property SILDeclRef's refer to the "originator"
+  // of the thunk, we need to mangle distributed thunks of accessors
+  // specially.
+  if (auto *accessor = dyn_cast<AccessorDecl>(thunk)) {
+    // TODO: This needs to use accessor type instead of
+    //       distributed thunk after all SILDeclRefs are switched
+    //       to use "originator" instead of the thunk itself.
+    //
+    // ```
+    // beginMangling();
+    // appendContextOf(thunk);
+    // appendDeclName(accessor->getStorage());
+    // appendDeclType(accessor, FunctionMangling);
+    // appendOperator("F");
+    // appendSymbolKind(SymbolKind::DistributedThunk);
+    // return finalize();
+    // ```
+    auto *storage = accessor->getStorage();
+    thunk = storage->getDistributedThunk();
+    assert(thunk);
+  }
+
   return mangleEntity(thunk, SymbolKind::DistributedThunk);
 }

lib/SILGen/SILGenLValue.cpp

@@ -3386,13 +3386,14 @@ void LValue::addMemberVarComponent(SILGenFunction &SGF, SILLocation loc,
 
     void emitUsingDistributedThunk() {
       auto *var = cast<VarDecl>(Storage);
-      SILDeclRef accessor(var->getDistributedThunk(), SILDeclRef::Kind::Func,
+      SILDeclRef accessor(var->getAccessor(AccessorKind::Get),
+                          SILDeclRef::Kind::Func,
                           /*isForeign=*/false, /*isDistributed=*/true);
 
       auto typeData = getLogicalStorageTypeData(
           SGF.getTypeExpansionContext(), SGF.SGM, AccessKind, FormalRValueType);
 
-      asImpl().emitUsingGetterSetter(accessor, /*isDirect=*/false, typeData);
+      asImpl().emitUsingGetterSetter(accessor, /*isDirect=*/true, typeData);
     }
 
   } emitter(SGF, loc, var, subs, isSuper, accessKind,

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -725,25 +725,10 @@ static FuncDecl *createDistributedThunkFunction(FuncDecl *func) {
   }
   ParameterList *params = ParameterList::create(C, paramDecls); // = funcParams->clone(C);
 
-  FuncDecl *thunk = nullptr;
-  if (auto *accessor = dyn_cast<AccessorDecl>(func)) {
-    auto *distributedVar = cast<VarDecl>(accessor->getStorage());
-
-    thunk = AccessorDecl::create(
-        C, /*declLoc=*/accessor->getLoc(), /*accessorKeywordLoc=*/SourceLoc(),
-        AccessorKind::Get, distributedVar,
-        /*staticLoc=*/SourceLoc(), StaticSpellingKind::None,
-        /*async=*/true, /*asyncLoc=*/SourceLoc(),
-        /*throws=*/true, /*throwsLoc=*/SourceLoc(), genericParamList, params,
-        func->getResultInterfaceType(), accessor->getDeclContext());
-
-    thunk->setImplicit();
-  } else {
-    thunk = FuncDecl::createImplicit(
-        C, swift::StaticSpellingKind::None, func->getName(), SourceLoc(),
-        /*async=*/true, /*throws=*/true, genericParamList, params,
-        func->getResultInterfaceType(), DC);
-  }
+  FuncDecl *thunk = FuncDecl::createImplicit(
+      C, swift::StaticSpellingKind::None, thunkName, SourceLoc(),
+      /*async=*/true, /*throws=*/true, genericParamList, params,
+      func->getResultInterfaceType(), DC);
 
   assert(thunk && "couldn't create a distributed thunk");
 

lib/Sema/MiscDiagnostics.cpp

@@ -1424,10 +1424,7 @@ static void diagRecursivePropertyAccess(const Expr *E, const DeclContext *DC) {
           if (MRE->getAccessSemantics() == AccessSemantics::Ordinary) {
             bool shouldDiagnose = false;
             // Warn about any property access in the getter.
-            //
-            // Distributed thunks have to refer to the "local" version
-            // of the property directly with implicit `self.` base.
-            if (Accessor->isGetter() && !Accessor->isDistributedThunk())
+            if (Accessor->isGetter())
               shouldDiagnose = !isStore;
             // Warn about stores in the setter, but allow loads.
             if (Accessor->isSetter())

lib/Sema/TypeCheckConcurrency.cpp

@@ -3905,11 +3905,7 @@ bool HasIsolatedSelfRequest::evaluate(
 
   // For accessors, consider the storage declaration.
   if (auto accessor = dyn_cast<AccessorDecl>(value)) {
-    // distributed thunks are accessors only in spirit and
-    // should be handled as regular functions from isolation
-    // perspective.
-    if (!accessor->isDistributedThunk())
-      value = accessor->getStorage();
+    value = accessor->getStorage();
   }
 
   // Check whether this member can be isolated to an actor at all.