[Distributed] Remove @_dynamic replacements; impl remoteCall ad-hoc reqs

Squashed commit of the following:

commit e5a05ff
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Thu Jan 27 17:45:31 2022 +0900

    cleanup

commit 1f751ce
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Thu Jan 27 14:50:33 2022 +0900

    cleanups

commit c632f32
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Thu Jan 27 14:01:09 2022 +0900

    add test for generic from actor decl

commit 09b8bd5
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Thu Jan 27 14:00:58 2022 +0900

    cleanups

commit 31f4d0c
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Thu Jan 27 11:40:51 2022 +0900

    fix test

commit ad4db2f
Merge: 97227ed 07e2dfd
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Jan 26 23:31:41 2022 +0900

    Merge branch 'main' into wip-zzz

commit 97227ed
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Jan 26 21:01:25 2022 +0900

    remove @_dynamic methods!

    fix tests

commit 1c79344
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Jan 19 12:51:09 2022 +0900

    cleanup

    wip

    stuck

    fixed the stack cleanups

    cleanups pretty good now

    weird load

    rki

    works

    remove hack

    add take + throw + return

    fix test

    more tests fixed

    more tests fixed

    more tests fixed

commit 3ed494c
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Tue Jan 18 21:09:28 2022 +0900

    stack issues in SIL verification

commit 5cf43a7
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Tue Jan 18 09:19:51 2022 +0900

    about to call the remoteCall

    goot to return, but missing subs

commit df8e471
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Thu Jan 13 14:09:49 2022 +0900

    [Distributed] Refactor Invocation to Decoder/Encoder

    getting there

    done-recording

    working on the string init

    stuck trying to get String initializer SILFunction

    created the remote call target

commit fc7bd62
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Jan 12 23:01:14 2022 +0900

    [Distributed] Pass arguments from Invocation to HBuffer

commit cafc2cc
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Jan 12 22:08:47 2022 +0900

    works

commit a7d0183
Author: Pavel Yaskevich <[email protected]>
Date:   Tue Jan 11 15:48:58 2022 -0800

    [Distributed] Adjust interface of `swift_distributed_execute_target`

    Since this is a special function, `calleeContext` doesn't point to
    a direct parent but instead both parent context (uninitialized)
    and resume function are passed as last arguments which means that
    `callContext` has to act as an intermediate context in call to accessor.

commit c1f830b
Author: Pavel Yaskevich <[email protected]>
Date:   Tue Jan 11 17:00:08 2022 -0800

    [Distributed] Drop optionality from result buffer in `_executeDistributedTarget`

    `RawPointer?` is lowered into a two arguments since it's a struct,
    to make it easy let's just allocate an empty pointer for `Void` result.

commit c83c2c3
Author: Pavel Yaskevich <[email protected]>
Date:   Tue Jan 11 17:02:45 2022 -0800

    [Distributed] NFC: Update _remoteCall test-case to check multiple different result types

commit 29e7cf5
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Jan 12 21:32:37 2022 +0900

    wip

commit 9128ecc
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Jan 12 20:46:20 2022 +0900

    wip

commit a6b2a62
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Jan 12 20:38:22 2022 +0900

    wip

commit 8b188f0
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Jan 12 16:55:10 2022 +0900

    wip

commit 3796bec
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Jan 12 16:55:02 2022 +0900

    wip

commit 0ffc68b
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Tue Jan 11 21:44:58 2022 +0900

    [Distributed] Implementing ad-hoc protocol requirements

commit 7886257
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Thu Jan 6 18:03:54 2022 +0900

    cleanup

commit 5f4ab89
Merge: 24a628e fdda6f2
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Thu Jan 6 15:51:39 2022 +0900

    Merge branch 'main' into wip-impl-execute-swift

commit 24a628e
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Thu Jan 6 15:33:21 2022 +0900

    wip

commit 69e7fed
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Dec 22 06:36:45 2021 +0900

    [Distributed] comment out distributed_actor_remoteCall for now

commit 376733a
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Tue Dec 21 16:00:06 2021 +0900

    reimplement distributed get type info impls

commit 74ab478
Author: Konrad `ktoso` Malawski <[email protected]>
Date:   Wed Dec 15 21:37:08 2021 +0900

    [Distributed] Implement func metadata and executeDistributedTarget

    dont expose new entrypoints

    able to get all the way to calling _execute

Author: ktoso

include/swift/AST/ASTContext.h

@@ -659,6 +659,50 @@ class ASTContext final {
   // Retrieve the declaration of Swift._stdlib_isOSVersionAtLeast.
   FuncDecl *getIsOSVersionAtLeastDecl() const;
 
+  /// Retrieve the declaration of DistributedActorSystem.remoteCall(Void)(...).
+  ///
+  /// \param actorOrSystem distributed actor or actor system to get the
+  /// remoteCall function for. Since the method we're looking for is an ad-hoc
+  /// requirement, a specific type MUST be passed here as it is not possible
+  /// to obtain the decl from just the `DistributedActorSystem` protocol type.
+  /// \param isVoidReturn true if the call will be returning `Void`.
+  AbstractFunctionDecl *getRemoteCallOnDistributedActorSystem(
+      NominalTypeDecl *actorOrSystem,
+      bool isVoidReturn) const;
+
+  // Retrieve the declaration of DistributedInvocationEncoder.recordArgument(_:).
+  //
+  // \param nominal optionally provide a 'NominalTypeDecl' from which the
+  // function decl shall be extracted. This is useful to avoid witness calls
+  // through the protocol which is looked up when nominal is null.
+  FuncDecl *getRecordArgumentOnDistributedInvocationEncoder(
+      NominalTypeDecl *nominal = nullptr) const;
+
+  // Retrieve the declaration of DistributedInvocationEncoder.recordErrorType().
+  //
+  // \param nominal optionally provide a 'NominalTypeDecl' from which the
+  // function decl shall be extracted. This is useful to avoid witness calls
+  // through the protocol which is looked up when nominal is null.
+  FuncDecl *getRecordErrorTypeOnDistributedInvocationEncoder(
+      NominalTypeDecl *nominal = nullptr) const;
+
+  // Retrieve the declaration of DistributedInvocationEncoder.recordReturnType().
+  //
+  // \param nominal optionally provide a 'NominalTypeDecl' from which the
+  // function decl shall be extracted. This is useful to avoid witness calls
+  // through the protocol which is looked up when nominal is null.
+  FuncDecl *getRecordReturnTypeOnDistributedInvocationEncoder(
+      NominalTypeDecl *nominal = nullptr) const;
+
+  // Retrieve the declaration of DistributedInvocationEncoder.doneRecording().
+  //
+  // \param nominal optionally provide a 'NominalTypeDecl' from which the
+  // function decl shall be extracted. This is useful to avoid witness calls
+  // through the protocol which is looked up when nominal is null.
+  FuncDecl *getDoneRecordingOnDistributedInvocationEncoder(
+      NominalTypeDecl *nominal = nullptr) const;
+
+
   /// Look for the declaration with the given name within the
   /// passed in module.
   void lookupInModule(ModuleDecl *M, StringRef name,

include/swift/AST/Decl.h

@@ -3364,13 +3364,17 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
                                           OptionSet<LookupDirectFlags> flags =
                                           OptionSet<LookupDirectFlags>());
 
-  /// Find the '_remote_<...>' counterpart function to a 'distributed func'.
-  ///
-  /// If the passed in function is not distributed this function returns null.
-  AbstractFunctionDecl* lookupDirectRemoteFunc(AbstractFunctionDecl *func);
+  /// Find the distributed actor system instance of this distributed actor.
+  VarDecl *getDistributedActorSystemProperty() const;
 
   /// Find, or potentially synthesize, the implicit 'id' property of this actor.
-  ValueDecl *getDistributedActorIDProperty() const;
+  VarDecl *getDistributedActorIDProperty() const;
+
+  /// Find the 'makeInvocation' function.
+  AbstractFunctionDecl* getDistributedActorSystemMakeInvocationEncoderFunction() const;
+
+  /// Find the 'RemoteCallTarget.init(_mangledName:)' initializer function
+  ConstructorDecl* getDistributedRemoteCallTargetInitFunction() const;
 
   /// Collect the set of protocols to which this type should implicitly
   /// conform, such as AnyObject (for classes).
@@ -6245,10 +6249,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Returns 'true' if the function is distributed.
   bool isDistributed() const;
 
-  /// Get (or synthesize)  the associated remote function for this one.
-  /// For example, for `distributed func hi()` get `func _remote_hi()`.
-  AbstractFunctionDecl *getDistributedActorRemoteFuncDecl() const;
-
   PolymorphicEffectKind getPolymorphicEffectKind(EffectKind kind) const;
 
   // FIXME: Hack that provides names with keyword arguments for accessors.
@@ -6388,6 +6388,11 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     && getSILSynthesizeKind() == SILSynthesizeKind::DistributedActorFactory;
   }
 
+  /// Determines whether this function is a 'remoteCall' function,
+  /// which is used as ad-hoc protocol requirement by the
+  /// 'DistributedActorSystem' protocol.
+  bool isDistributedActorSystemRemoteCall(bool isVoidReturn) const;
+
   /// For a method of a class, checks whether it will require a new entry in the
   /// vtable.
   bool needsNewVTableEntry() const;

include/swift/AST/DiagnosticsSema.def

@@ -4450,6 +4450,12 @@ ERROR(distributed_actor_protocol_illegal_inheritance,none,
       (DeclName))
 ERROR(broken_distributed_actor_requirement,none,
       "DistributedActor protocol is broken: unexpected requirement", ())
+ERROR(distributed_actor_system_conformance_missing_adhoc_requirement,none,
+      "%0 %1 is missing witness for protocol requirement %2"
+      "", (DescriptiveDeclKind, DeclName, DeclName))
+NOTE(note_distributed_actor_system_conformance_missing_adhoc_requirement,none,
+      "protocol %0 requires function %1 with signature:\n%2",
+     (DeclName, DeclName, StringRef))
 
 ERROR(override_implicit_unowned_executor,none,
       "cannot override an actor's 'unownedExecutor' property that wasn't "

include/swift/AST/KnownIdentifiers.def

@@ -257,26 +257,38 @@ IDENTIFIER(version)
 IDENTIFIER_(StringProcessing)
 
 // Distributed actors
+IDENTIFIER(ActorID)
+IDENTIFIER(ActorSystem)
+IDENTIFIER(ID)
+IDENTIFIER(Invocation)
+IDENTIFIER(__isRemoteActor)
+IDENTIFIER(_distributedActorDestroy)
+IDENTIFIER(_distributedActorRemoteInitialize)
 IDENTIFIER(actor)
 IDENTIFIER(actorReady)
-IDENTIFIER(ActorSystem)
 IDENTIFIER(actorSystem)
-IDENTIFIER(ActorID)
 IDENTIFIER(actorType)
-IDENTIFIER(using)
 IDENTIFIER(assignID)
+IDENTIFIER(decodeNext)
+IDENTIFIER(doneRecording)
+IDENTIFIER(id)
+IDENTIFIER(invocation)
+IDENTIFIER(invocationDecoder)
+IDENTIFIER(makeInvocationEncoder)
+IDENTIFIER(on)
+IDENTIFIER(recordArgument)
+IDENTIFIER(recordErrorType)
+IDENTIFIER(recordGenericSubstitution)
+IDENTIFIER(recordReturnType)
+IDENTIFIER(remoteCall)
+IDENTIFIER(remoteCallVoid)
 IDENTIFIER(resignID)
 IDENTIFIER(resolve)
-IDENTIFIER(remoteCall)
-IDENTIFIER(makeInvocationEncoder)
+IDENTIFIER(returning)
 IDENTIFIER(system)
-IDENTIFIER(ID)
-IDENTIFIER(id)
-IDENTIFIER(Invocation)
-IDENTIFIER(invocationDecoder)
-IDENTIFIER(_distributedActorRemoteInitialize)
-IDENTIFIER(_distributedActorDestroy)
-IDENTIFIER(__isRemoteActor)
+IDENTIFIER(target)
+IDENTIFIER(throwing)
+IDENTIFIER(using)
 IDENTIFIER(whenLocal)
 
 #undef IDENTIFIER

include/swift/AST/KnownProtocols.def

@@ -97,10 +97,10 @@ PROTOCOL(Differentiable)
 
 // Distributed Actors
 PROTOCOL(DistributedActor)
-PROTOCOL(ActorIdentity)
 PROTOCOL(DistributedActorSystem)
 PROTOCOL(DistributedTargetInvocationEncoder)
 PROTOCOL(DistributedTargetInvocationDecoder)
+PROTOCOL(DistributedTargetInvocationResultHandler)
 
 PROTOCOL(AsyncSequence)
 PROTOCOL(AsyncIteratorProtocol)

include/swift/AST/KnownSDKDecls.def

@@ -19,7 +19,6 @@
 #  define KNOWN_SDK_FUNC_DECL(Module, Name, Id)
 #endif
 
-KNOWN_SDK_FUNC_DECL(Distributed, MissingDistributedActorSystem, "_missingDistributedActorSystem")
 KNOWN_SDK_FUNC_DECL(Distributed, IsRemoteDistributedActor, "__isRemoteActor")
 
 #undef KNOWN_SDK_FUNC_DECL

include/swift/AST/KnownSDKTypes.def

@@ -45,8 +45,7 @@ KNOWN_SDK_TYPE_DECL(Concurrency, TaskLocal, ClassDecl, 1)
 
 // Distributed actors
 KNOWN_SDK_TYPE_DECL(Distributed, DistributedActor, ProtocolDecl, 0)
-KNOWN_SDK_TYPE_DECL(Distributed, ActorIdentity, ProtocolDecl, 0)
-KNOWN_SDK_TYPE_DECL(Distributed, AnyActorIdentity, StructDecl, 0)
+KNOWN_SDK_TYPE_DECL(Distributed, RemoteCallTarget, StructDecl, 0)
 
 // String processing
 KNOWN_SDK_TYPE_DECL(StringProcessing, Regex, StructDecl, 1)

include/swift/AST/TypeCheckRequests.h

@@ -1017,18 +1017,36 @@ class IsDistributedActorRequest :
     bool isCached() const { return true; }
 };
 
-/// Obtain the 'remote' counterpart of a 'distributed func'.
-class GetDistributedRemoteFuncRequest :
-    public SimpleRequest<GetDistributedRemoteFuncRequest,
-                         AbstractFunctionDecl *(AbstractFunctionDecl *),
+/// Obtain the 'remoteCall' function of a 'DistributedActorSystem'.
+class GetDistributedActorSystemRemoteCallFunctionRequest :
+    public SimpleRequest<GetDistributedActorSystemRemoteCallFunctionRequest,
+                         AbstractFunctionDecl *(NominalTypeDecl *, bool voidReturn),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  AbstractFunctionDecl *evaluate(Evaluator &evaluator, AbstractFunctionDecl *func) const;
+  AbstractFunctionDecl *evaluate(Evaluator &evaluator, NominalTypeDecl *actorSystem, bool voidReturn) const;
+
+public:
+    // Caching
+    bool isCached() const { return true; }
+};
+
+/// Obtain the 'actorSystem' property of a 'distributed actor'.
+class GetDistributedActorSystemPropertyRequest :
+    public SimpleRequest<GetDistributedActorSystemPropertyRequest,
+                         VarDecl *(NominalTypeDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  VarDecl *evaluate(Evaluator &evaluator, NominalTypeDecl *actor) const;
 
 public:
     // Caching
@@ -1038,15 +1056,15 @@ class GetDistributedRemoteFuncRequest :
 /// Obtain the 'id' property of a 'distributed actor'.
 class GetDistributedActorIDPropertyRequest :
     public SimpleRequest<GetDistributedActorIDPropertyRequest,
-                         ValueDecl *(NominalTypeDecl *),
+                         VarDecl *(NominalTypeDecl *),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  ValueDecl *evaluate(Evaluator &evaluator, NominalTypeDecl *actor) const;
+  VarDecl *evaluate(Evaluator &evaluator, NominalTypeDecl *actor) const;
 
 public:
     // Caching

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -105,9 +105,12 @@ SWIFT_REQUEST(TypeChecker, IsDefaultActorRequest,
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsDistributedActorRequest, bool(NominalTypeDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, GetDistributedRemoteFuncRequest, AbstractFunctionDecl *(AbstractFunctionDecl *),
+SWIFT_REQUEST(TypeChecker, GetDistributedActorSystemRemoteCallFunctionRequest,
+              AbstractFunctionDecl *(NominalTypeDecl *, bool),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, GetDistributedActorIDPropertyRequest, ValueDecl *(NominalTypeDecl *),
+SWIFT_REQUEST(TypeChecker, GetDistributedActorIDPropertyRequest, VarDecl *(NominalTypeDecl *),
+              Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, GetDistributedActorSystemPropertyRequest, VarDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GlobalActorInstanceRequest,
               VarDecl *(NominalTypeDecl *),

include/swift/SILOptimizer/Utils/DistributedActor.h

@@ -15,6 +15,7 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
+#include "swift/AST/Decl.h"
 #include <utility>
 
 namespace swift {
@@ -35,18 +36,26 @@ class SILValue;
 /// \returns nullptr if the function does not have such a parameter.
 SILArgument *findFirstDistributedActorSystemArg(SILFunction &F);
 
-/// Emit a call to a witness of the actor actorSystem protocol.
+/// Emit a call to a witness of the DistributedActorSystem protocol.
 ///
 /// \param methodName The name of the method on the DistributedActorSystem protocol.
-/// \param actorSystem The actorSystem on which to invoke the method
+/// \param base The base on which to invoke the method
 /// \param actorType If non-empty, the type of the distributed actor that is
 /// provided as one of the arguments.
-/// \param args The arguments provided to the call, not including the actorSystem.
+/// \param args The arguments provided to the call, not including the base.
 /// \param tryTargets For a call that can throw, the normal and error basic
 /// blocks that the call will branch to.
 void emitDistributedActorSystemWitnessCall(
     SILBuilder &B, SILLocation loc, DeclName methodName,
-    SILValue actorSystem, SILType actorType, llvm::ArrayRef<SILValue> args,
+    SILValue base, SILType actorType, llvm::ArrayRef<SILValue> args,
+    llvm::Optional<std::pair<SILBasicBlock *, SILBasicBlock *>> tryTargets =
+        llvm::None);
+
+/// Emit a call to a witness of the passed 'proto' protocol.
+void emitDistributedWitnessCall(
+    SILBuilder &B, SILLocation loc, DeclName methodName,
+    SILValue base, ProtocolDecl *proto, SILType actorType,
+    llvm::ArrayRef<SILValue> args,
     llvm::Optional<std::pair<SILBasicBlock *, SILBasicBlock *>> tryTargets =
         llvm::None);