[Distributed] synthesize _remote and implement via dynamic

include/swift/AST/Decl.h

@@ -5265,7 +5265,10 @@ class ParamDecl : public VarDecl {
 
   /// Create a new ParamDecl identical to the first except without the interface type.
   static ParamDecl *cloneWithoutType(const ASTContext &Ctx, ParamDecl *PD);
-
+
+  /// Create a an identical copy of this ParamDecl.
+  static ParamDecl *clone(const ASTContext &Ctx, ParamDecl *PD);
+
   /// Retrieve the argument (API) name for this function parameter.
   Identifier getArgumentName() const {
     return ArgumentNameAndDestructured.getPointer();

include/swift/AST/DiagnosticsSema.def

@@ -4444,11 +4444,9 @@ ERROR(distributed_actor_func_param_not_codable,none,
 ERROR(distributed_actor_func_result_not_codable,none,
       "distributed function result type %0 does not conform to 'Codable'",
       (Type))
-ERROR(distributed_actor_func_missing_remote_func,none,
-      "distributed function is missing its remote static func implementation (%0). "
-      "You may want to use a distributed actor SwiftPM plugin to generate those, "
-      "or implement it manually.",
-      (Identifier))
+ERROR(distributed_actor_remote_func_implemented_manually,none,
+      "Distributed function's %0 remote counterpart %1 cannot not be implemented manually.",
+      (Identifier, Identifier))
 ERROR(distributed_actor_remote_func_is_not_static,none,
       "remote function %0 must be static.",
       (DeclName))

include/swift/AST/KnownSDKDecls.def

@@ -19,6 +19,8 @@
 #  define KNOWN_SDK_FUNC_DECL(Module, Name, Id)
 #endif
 
+KNOWN_SDK_FUNC_DECL(Distributed, MissingDistributedActorTransport, "_missingDistributedActorTransport")
+KNOWN_SDK_FUNC_DECL(Distributed, IsRemoteDistributedActor, "__isRemoteActor")
 
 #undef KNOWN_SDK_FUNC_DECL
 

include/swift/AST/ParameterList.h

@@ -67,6 +67,14 @@ class alignas(ParamDecl *) ParameterList final :
     return create(decl->getASTContext(), decl);
   }
 
+  static ParameterList *clone(const ASTContext &Ctx, ParameterList *PL) {
+    SmallVector<ParamDecl*, 4> params;
+    params.reserve(PL->size());
+    for (auto p : *PL)
+      params.push_back(ParamDecl::clone(Ctx, p));
+    return ParameterList::create(Ctx, params);
+  }
+
   SourceLoc getLParenLoc() const { return LParenLoc; }
   SourceLoc getRParenLoc() const { return RParenLoc; }
 

lib/AST/ASTVerifier.cpp

@@ -2309,6 +2309,12 @@ class Verifier : public ASTWalker {
     }
 
     void verifyChecked(ValueDecl *VD) {
+    if (VD->getName().isSimpleName()  &&
+          !VD->getName().isSpecial() &&
+          VD->getName().getBaseIdentifier().str() == "echo") {
+        VD->dump();
+      }
+
       if (VD->getInterfaceType()->hasError()) {
         Out << "checked decl cannot have error type\n";
         VD->dump(Out);

lib/AST/Decl.cpp

@@ -6313,6 +6313,12 @@ ParamDecl *ParamDecl::cloneWithoutType(const ASTContext &Ctx, ParamDecl *PD) {
   return Clone;
 }
 
+ParamDecl *ParamDecl::clone(const ASTContext &Ctx, ParamDecl *PD) {
+  auto *Clone = ParamDecl::cloneWithoutType(Ctx, PD);
+  Clone->setInterfaceType(PD->getInterfaceType());
+  return Clone;
+}
+
 /// Retrieve the type of 'self' for the given context.
 Type DeclContext::getSelfTypeInContext() const {
   assert(isTypeContext());

lib/SIL/IR/SILDeclRef.cpp

@@ -121,8 +121,8 @@ bool swift::requiresForeignEntryPoint(ValueDecl *vd) {
   return false;
 }
 
-SILDeclRef::SILDeclRef(ValueDecl *vd, SILDeclRef::Kind kind, bool isForeign,
-                       bool isDistributed,
+SILDeclRef::SILDeclRef(ValueDecl *vd, SILDeclRef::Kind kind,
+                       bool isForeign, bool isDistributed,
                        AutoDiffDerivativeFunctionIdentifier *derivativeId)
     : loc(vd), kind(kind), isForeign(isForeign), isDistributed(isDistributed),
       defaultArgIndex(0), pointer(derivativeId) {}
@@ -171,7 +171,7 @@ SILDeclRef::SILDeclRef(SILDeclRef::Loc baseLoc, bool asForeign, bool asDistribut
 
 SILDeclRef::SILDeclRef(SILDeclRef::Loc baseLoc,
                        GenericSignature prespecializedSig)
-    : SILDeclRef(baseLoc, false) {
+    : SILDeclRef(baseLoc, false, false) {
   pointer = prespecializedSig.getPointer();
 }
 

lib/SILGen/SILGenBridging.cpp

@@ -1960,7 +1960,7 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
   //
   // func X_distributedThunk(...) async throws -> T {
   //   if __isRemoteActor(self) {
-  //     return try await Self.__remote_X(...)
+  //     return try await self._remote_X(...)
   //   } else {
   //     return try await self.X(...)
   //   }
@@ -2011,19 +2011,9 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
   //   ...
   // }
   {
-    auto desc = UnqualifiedLookupDescriptor(
-        DeclNameRef(ctx.Id___isRemoteActor),
-        fd->getDeclContext(), fd->getLoc(), UnqualifiedLookupOptions());
-    auto lookup =
-        evaluateOrDefault(ctx.evaluator, UnqualifiedLookupRequest{desc}, {});
-    FuncDecl *isRemoteFn = nullptr;
-    for (const auto &result : lookup) {
-      // FIXME: Validate this further, because we're assuming the exact type.
-      if (auto func = dyn_cast<FuncDecl>(result.getValueDecl())) {
-        isRemoteFn = func;
-        break;
-      }
-    }
+    FuncDecl* isRemoteFn = ctx.getIsRemoteDistributedActor();
+    assert(isRemoteFn &&
+           "Could not find 'is remote' function, is the '_Distributed' module available?");
 
     ManagedValue selfAnyObject = B.createInitExistentialRef(loc, getLoweredType(ctx.getAnyObjectType()),
                                                         CanType(selfType),
@@ -2037,39 +2027,37 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
     B.createCondBranch(loc, isRemoteResultUnwrapped, isRemoteBB, isLocalBB);
   }
 
-
   // if __isRemoteActor(self) {
-  //   return try await Self._remote_X(...)
+  //   return try await self._remote_X(...)
   // }
   {
     B.emitBlock(isRemoteBB);
 
     auto *selfTyDecl = FunctionDC->getParent()->getSelfNominalTypeDecl();
-    // FIXME: should this be an llvm_unreachable instead?
     assert(selfTyDecl && "distributed function declared outside of actor");
 
-    auto selfMetatype = getLoweredType(selfTyDecl->getInterfaceType());
-    SILValue metatypeValue = B.createMetatype(loc, selfMetatype);
+//    auto selfMetatype = getLoweredType(selfTyDecl->getInterfaceType());
+//    SILValue metatypeValue = B.createMetatype(loc, selfMetatype);
 
     auto remoteFnDecl = selfTyDecl->lookupDirectRemoteFunc(fd);
     assert(remoteFnDecl && "Could not find _remote_<dist_func_name> function");
     auto remoteFnRef = SILDeclRef(remoteFnDecl);
 
     SILGenFunctionBuilder builder(SGM);
     auto remoteFnSIL = builder.getOrCreateFunction(loc, remoteFnRef, ForDefinition);
-
     SILValue remoteFn = B.createFunctionRefFor(loc, remoteFnSIL);
 
     auto subs = F.getForwardingSubstitutionMap();
 
     SmallVector<SILValue, 8> remoteParams(params);
-    remoteParams.emplace_back(metatypeValue);
+//     remoteParams.emplace_back(metatypeValue);
 
+    // B.createTryApply(loc, remoteFn, subs, params, remoteReturnBB, remoteErrorBB);
     B.createTryApply(loc, remoteFn, subs, remoteParams, remoteReturnBB, remoteErrorBB);
   }
 
   // else {
-  //   return try await self.X(...)
+  //   return (try)? (await)? self.X(...)
   // }
   {
     B.emitBlock(isLocalBB);

lib/Sema/CodeSynthesis.cpp

@@ -35,7 +35,7 @@
 #include "swift/Sema/ConstraintSystem.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
-#include "CodeSynthesisDistributedActor.cpp"
+#include "CodeSynthesisDistributedActor.cpp" // FIXME: remove this!!!
 using namespace swift;
 
 const bool IsImplicit = true;