[Distributed] initial distributed support, fixed availability (#37650)

* [Distributed] Initial distributed checking

* [Distributed] initial types shapes and conform to DistributedActor

* [Distributed] Require Codable params and return types

* [Distributed] initial synthesis of fields and constructors

* [Distributed] Field and initializer synthesis

* [Distributed] Codable requirement on distributed funcs; also handle <T: Codable>

* [Distributed] handle generic type params which are Codable in dist func

[Distributed] conformsToProtocol after all

* [Distributed] Implement remote flag on actors

* Implement remote flag on actors

* add test

* actor initializer that sets remote flag

[Distributed] conformances getting there

* [Distributed] dont require async throws; cleanup compile tests

* [Distributed] do not synthesize default implicit init, only our special ones

* [Distributed] properly synth inits and properties; mark actorTransport as _distributedActorIndependent

Also:

- do not synthesize default init() initializer for dist actor

* [Distributed] init(transport:) designated and typechecking

* [Distributed] dist actor initializers MUST delegate to local-init

* [Distributed] check if any ctors in delegation call init(transport:)

* [Distributed] check init(transport:) delegation through many inits; ban invoking init(resolve:using:) explicitly

* [Distributed] disable IRGen test for now

* [Distributed] Rebase cleanups

* [Concurrent] transport and address are concurrent value

* [Distributed] introduce -enable-experimental-distributed flag

* rebase adjustments again

* rebase again...

* [Distributed] distributed functions are implicitly async+throws outside the actor

* [Distributed] implicitly throwing and async distributed funcs

* remove printlns

* add more checks to implicit function test

* [Distributed] resolve initializer now marks the isRemote actor flag

* [Distributed] distributedActor_destroy invoked instead, rather than before normal

* [Distributed] Generate distributed thunk for actors

* [distributed] typechecking for _remote_ functions existing, add tests for remote funcs

* adding one XFAIL'ed task & actor lifetime test

The `executor_deinit1` test fails 100% of the time
(from what I've seen) so I thought we could track
and see when/if someone happens to fix this bug.

Also, added extra coverage for #36298 via `executor_deinit2`

* Fix a memory issue with actors in the runtime system, by @phausler

* add new test that now passes because of patch by @phausler

See previous commit in this PR.
Test is based on one from rdar://74281361

* fix all tests that require the _remote_ function stubs

* Do not infer @actorIndependent onto `let` decls

* REVERT_ME: remove some tests that hacky workarounds will fail

* another flaky test, help build toolchain

* [Distributed] experimental distributed implies experimental concurrency

* [Distributed] Allow distributed function that are not marked async or throws

* [Distributed] make attrs SIMPLE to get serialization generated

* [Distributed] ActorAddress must be Hashable

* [Distributed] Implement transport.actorReady call in local init

* cleanup after rebase

* [Distributed] add availability attributes to all distributed actor code

* cleanup - this fixed some things

* fixing up

* fixing up

* [Distributed] introduce new Distributed module

* [Distributed] diagnose when missing 'import _Distributed'

* [Distributed] make all tests import the module

* more docs on address

* [Distributed] fixup merge issues

* cleanup: remove unnecessary code for now SIMPLE attribute

* fix: fix getActorIsolationOfContext

* [Distributed] cmake: depend on _concurrency module

* fixing tests...

* Revert "another flaky test, help build toolchain"

This reverts commit 83ae665.

* remove xfail

* clenup some IR and SIL tests

* cleanup

* [Distributed] fix cmake test and ScanDependencies/can_import_with_map.swift

* [Distributed] fix flags/build tests

* cleanup: use isDistributed wherever possible

* [Distributed] don't import Dispatch in tests

* dont link distributed in stdlib unittest

* trying always append distributed module

* cleanups

* [Distributed] move all tests to Distributed/ directory

* [lit] try to fix lit test discovery

* [Distributed] update tests after diagnostics for implicit async changed

* [Distributed] Disable remote func tests on Windows for now

* Review cleanups

* [Distributed] fix typo, fixes Concurrency/actor_isolation_objc.swift

* [Distributed] attributes are DistributedOnly (only)

* cleanup

* [Distributed] cleanup: rely on DistributedOnly for guarding the keyword

* Update include/swift/AST/ActorIsolation.h

Co-authored-by: Doug Gregor <[email protected]>

* introduce isAnyThunk, minor cleanup

* wip

* [Distributed] move some type checking to TypeCheckDistributed.cpp

* [TypeCheckAttr] remove extra debug info

* [Distributed/AutoDiff] fix SILDeclRef creation which caused AutoDiff issue

* cleanups

* [lit] remove json import from lit test suite, not needed after all

* [Distributed] distributed functions only in DistributedActor protocols

* [Distributed] fix flag overlap & build setting

* [Distributed] Simplify noteIsolatedActorMember to not take bool distributed param

* [Distributed] make __isRemote not public

* [Distributed] Fix availability and remove actor class tests

* [actorIndependent] do not apply actorIndependent implicitly to values where it would be illegal to apply

* [Distributed] disable tests until issue fixed

Co-authored-by: Dario Rexin <[email protected]>
Co-authored-by: Kavon Farvardin <[email protected]>
Co-authored-by: Doug Gregor <[email protected]>

Author: 4 people

CMakeLists.txt

@@ -418,6 +418,10 @@ option(SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY
   "Enable experimental Swift concurrency model"
   FALSE)
 
+option(SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED
+  "Enable experimental distributed actors and functions"
+  FALSE)
+
 option(SWIFT_ENABLE_DISPATCH
   "Enable use of libdispatch"
   TRUE)
@@ -901,6 +905,7 @@ if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
 
   message(STATUS "Differentiable Programming Support: ${SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING}")
   message(STATUS "Concurrency Support: ${SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY}")
+  message(STATUS "Distributed Support: ${SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED}")
   message(STATUS "")
 else()
   message(STATUS "Not building Swift standard library, SDK overlays, and runtime")

include/swift/AST/ASTMangler.h

@@ -88,6 +88,7 @@ class ASTMangler : public Mangler {
     DynamicThunk,
     SwiftAsObjCThunk,
     ObjCAsSwiftThunk,
+    DistributedThunk,
   };
 
   ASTMangler(bool DWARFMangling = false)

include/swift/AST/ActorIsolation.h

@@ -48,6 +48,10 @@ class ActorIsolation {
     /// For example, a mutable stored property or synchronous function within
     /// the actor is isolated to the instance of that actor.
     ActorInstance,
+    /// The declaration is isolated to a (potentially) distributed actor.
+    /// Distributed actors may access _their_ state (same as 'ActorInstance')
+    /// however others may not access any properties on other distributed actors.
+    DistributedActorInstance,
     /// The declaration is explicitly specified to be independent of any actor,
     /// meaning that it can be used from any actor but is also unable to
     /// refer to the isolated state of any given actor.
@@ -88,6 +92,10 @@ class ActorIsolation {
     return ActorIsolation(ActorInstance, actor);
   }
 
+  static ActorIsolation forDistributedActorInstance(NominalTypeDecl *actor) {
+    return ActorIsolation(DistributedActorInstance, actor);
+  }
+
   static ActorIsolation forGlobalActor(Type globalActor, bool unsafe) {
     return ActorIsolation(
         unsafe ? GlobalActorUnsafe : GlobalActor, globalActor);
@@ -100,7 +108,7 @@ class ActorIsolation {
   bool isUnspecified() const { return kind == Unspecified; }
 
   NominalTypeDecl *getActor() const {
-    assert(getKind() == ActorInstance);
+    assert(getKind() == ActorInstance || getKind() == DistributedActorInstance);
     return actor;
   }
 
@@ -131,6 +139,7 @@ class ActorIsolation {
       return true;
 
     case ActorInstance:
+    case DistributedActorInstance:
       return lhs.actor == rhs.actor;
 
     case GlobalActor:

include/swift/AST/Attr.def

@@ -659,6 +659,21 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(spawn, Spawn,
   APIBreakingToAdd | APIBreakingToRemove,
   117)
 
+CONTEXTUAL_SIMPLE_DECL_ATTR(distributed, DistributedActor,
+  DeclModifier | OnClass | OnFunc |
+  DistributedOnly |
+  ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  118)
+
+SIMPLE_DECL_ATTR(_distributedActorIndependent, DistributedActorIndependent,
+  OnFunc | OnVar |
+  DistributedOnly | UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  119)
+
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Attr.h

@@ -298,6 +298,9 @@ class DeclAttribute : public AttributeBase {
 
     /// Whether this attribute is only valid when concurrency is enabled.
     ConcurrencyOnly = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 16),
+
+    /// Whether this attribute is only valid when distributed is enabled.
+    DistributedOnly = 1ull << (unsigned(DeclKindIndex::Last_Decl) + 17),
   };
 
   LLVM_READNONE
@@ -392,6 +395,10 @@ class DeclAttribute : public AttributeBase {
     return getOptions(DK) & ConcurrencyOnly;
   }
 
+  static bool isDistributedOnly(DeclAttrKind DK) {
+    return getOptions(DK) & DistributedOnly;
+  }
+
   static bool isUserInaccessible(DeclAttrKind DK) {
     return getOptions(DK) & UserInaccessible;
   }

include/swift/AST/Builtins.def

@@ -724,6 +724,14 @@ BUILTIN_MISC_OPERATION(InitializeDefaultActor, "initializeDefaultActor", "", Spe
 /// Destroy the default-actor instance in a default actor object.
 BUILTIN_MISC_OPERATION(DestroyDefaultActor, "destroyDefaultActor", "", Special)
 
+/// Initialize a "proxy" for a distributed remote actor.
+BUILTIN_MISC_OPERATION(InitializeDistributedRemoteActor,
+                       "initializeDistributedRemoteActor", "", Special)
+
+/// Destroy the distributed-actor instance in a "proxy" actor object.
+BUILTIN_MISC_OPERATION(DestroyDistributedActor,
+                       "destroyDistributedActor", "", Special)
+
 /// Resume a non-throwing continuation normally with the given result.
 BUILTIN_MISC_OPERATION(ResumeNonThrowingContinuationReturning,
                        "resumeNonThrowingContinuationReturning", "", Special)

include/swift/AST/Decl.h

@@ -2346,6 +2346,8 @@ class ValueDecl : public Decl {
   /// Is this declaration marked with 'dynamic'?
   bool isDynamic() const;
 
+  bool isDistributedActorIndependent() const;
+
 private:
   bool isObjCDynamic() const {
     return isObjC() && isDynamic();
@@ -3164,6 +3166,11 @@ 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);
+
   /// Collect the set of protocols to which this type should implicitly
   /// conform, such as AnyObject (for classes).
   void getImplicitProtocols(SmallVectorImpl<ProtocolDecl *> &protocols);
@@ -3220,6 +3227,10 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// `Actor` protocol.
   bool isActor() const;
 
+  /// Whether this nominal type qualifies as a distributed actor, meaning that
+  /// it is either a distributed actor.
+  bool isDistributedActor() const;
+
   /// Return the range of semantics attributes attached to this NominalTypeDecl.
   auto getSemanticsAttrs() const
       -> decltype(getAttrs().getSemanticsAttrs()) {
@@ -3288,6 +3299,8 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// for types that are not global actors.
   VarDecl *getGlobalActorInstance() const;
 
+  bool hasDistributedActorLocalInitializer() const;
+
   /// Whether this type is a global actor, which can be used as an
   /// attribute to decorate declarations for inclusion in the actor-isolated
   /// state denoted by this type.
@@ -4003,6 +4016,7 @@ enum class KnownDerivableProtocolKind : uint8_t {
   AdditiveArithmetic,
   Differentiable,
   Actor,
+  DistributedActor,
 };
 
 /// ProtocolDecl - A declaration of a protocol, for example:
@@ -4196,6 +4210,10 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// semantics but has no corresponding witness table.
   bool isMarkerProtocol() const;
 
+  /// Is a protocol that can only be conformed by distributed actors.
+  /// Such protocols are allowed to contain distributed functions.
+  bool inheritsFromDistributedActor() const;
+
 private:
   void computeKnownProtocolKind() const;
 
@@ -4714,6 +4732,8 @@ class AbstractStorageDecl : public ValueDecl {
 
   bool hasAnyNativeDynamicAccessors() const;
 
+  bool isDistributedActorIndependent() const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_AbstractStorageDecl &&
@@ -5170,14 +5190,20 @@ class VarDecl : public AbstractStorageDecl {
     return getAttrs().getAttributes<SemanticsAttr>();
   }
 
-  /// Returns true if this VarDelc has the string \p attrValue as a semantics
+  /// Returns true if this VarDecl has the string \p attrValue as a semantics
   /// attribute.
   bool hasSemanticsAttr(StringRef attrValue) const {
     return llvm::any_of(getSemanticsAttrs(), [&](const SemanticsAttr *attr) {
       return attrValue.equals(attr->Value);
     });
   }
 
+  /// Whether the given name is actorAddress, which is used for distributed actors.
+  static bool isDistributedActorAddressName(ASTContext &ctx, DeclName name);
+
+  /// Whether the given name is actorTransport, which is used for distributed actors.
+  static bool isDistributedActorTransportName(ASTContext &ctx, DeclName name);
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { 
     return D->getKind() == DeclKind::Var || D->getKind() == DeclKind::Param; 
@@ -5855,6 +5881,9 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Returns if the function is 'rethrows' or 'reasync'.
   bool hasPolymorphicEffect(EffectKind kind) const;
 
+  /// Returns 'true' if the function is distributed.
+  bool isDistributed() const;
+
   PolymorphicEffectKind getPolymorphicEffectKind(EffectKind kind) const;
 
   // FIXME: Hack that provides names with keyword arguments for accessors.
@@ -6864,6 +6893,18 @@ class ConstructorDecl : public AbstractFunctionDecl {
   /// \endcode
   bool isObjCZeroParameterWithLongSelector() const;
 
+  /// Checks if the initializer is a distributed actor's 'local' initializer:
+  /// ```
+  /// init(transport: ActorTransport)
+  /// ```
+  bool isDistributedActorLocalInit() const;
+
+  /// Checks if the initializer is a distributed actor's 'resolve' initializer:
+  /// ```
+  /// init(resolve address: ActorAddress, using transport: ActorTransport)
+  /// ```
+  bool isDistributedActorResolveInit() const;
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Constructor;
   }

include/swift/AST/DiagnosticsParse.def

@@ -1822,7 +1822,7 @@ ERROR(pound_available_package_description_not_allowed, none,
 ERROR(availability_query_repeated_platform, none,
       "version for '%0' already specified", (StringRef))
 
-ERROR(attr_requires_concurrency,none,
+ERROR(attr_requires_concurrency, none,
       "'%0' %select{attribute|modifier}1 is only valid when experimental "
       "concurrency is enabled",
       (StringRef, bool))

include/swift/AST/DiagnosticsSema.def

@@ -4360,6 +4360,13 @@ ERROR(actor_isolated_non_self_reference,none,
         "actor-isolated %0 %1 can only be %select{referenced|mutated|used 'inout'}3 "
         "%select{from inside the actor|on 'self'}2",
         (DescriptiveDeclKind, DeclName, bool, unsigned))
+ERROR(distributed_actor_isolated_non_self_reference,none,
+      "distributed actor-isolated %0 %1 can only be referenced "
+      "inside the distributed actor",
+      (DescriptiveDeclKind, DeclName))
+ERROR(distributed_actor_needs_explicit_distributed_import,none,
+      "'_Distributed' module not imported, required for 'distributed actor'",
+      ())
 ERROR(actor_isolated_self_independent_context,none,
         "actor-isolated %0 %1 can not be %select{referenced|mutated|used 'inout'}2 from a "
         "non-isolated context",
@@ -4409,8 +4416,8 @@ ERROR(actor_isolated_from_async_let,none,
         "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from 'async let' initializer",
         (DescriptiveDeclKind, DeclName, unsigned))
 ERROR(actor_isolated_keypath_component,none,
-      "cannot form key path to actor-isolated %0 %1",
-      (DescriptiveDeclKind, DeclName))
+      "cannot form key path to%select{| distributed}0 actor-isolated %1 %2",
+      (bool, DescriptiveDeclKind, DeclName))
 ERROR(effectful_keypath_component,none,
       "cannot form key path to %0 with 'throws' or 'async'",
       (DescriptiveDeclKind))
@@ -4425,6 +4432,32 @@ NOTE(actor_isolated_sync_func,none,
      "calls to %0 %1 from outside of its actor context are "
      "implicitly asynchronous",
      (DescriptiveDeclKind, DeclName))
+NOTE(distributed_actor_isolated_method_note,none,
+      "only 'distributed' functions can be called from outside the distributed actor",
+      ())
+ERROR(distributed_actor_isolated_method,none,
+      "only 'distributed' functions can be called from outside the distributed actor", // TODO: more like 'non-distributed' ... defined here
+      ())
+ERROR(distributed_actor_func_param_not_codable,none,
+      "distributed function parameter '%0' of type %1 does not conform to 'Codable'",
+      (StringRef, Type))
+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_is_not_static,none,
+      "remote function %0 must be static.",
+      (DeclName))
+ERROR(distributed_actor_remote_func_is_not_async_throws,none,
+      "remote function %0 must be 'async throws'.",
+      (DeclName))
+ERROR(distributed_actor_remote_func_must_not_be_distributed,none,
+      "remote function %0 must be 'async throws'.",
+      (DeclName))
 NOTE(actor_mutable_state,none,
      "mutation of this %0 is only permitted within the actor",
      (DescriptiveDeclKind))
@@ -4514,6 +4547,60 @@ ERROR(actor_instance_property_wrapper,none,
       "the actor instance; consider 'nonisolated'",
       (Identifier, Identifier))
 
+ERROR(distributed_actor_func_defined_outside_of_distributed_actor,none,
+      "distributed function %0 is declared outside of an distributed actor",
+      (DeclName))
+ERROR(distributed_actor_local_init_explicitly_defined,none,
+      "'distributed actor' local-initializer 'init(transport:)' "
+      "cannot be implemented explicitly.",
+      ())
+ERROR(distributed_actor_init_resolve_must_not_be_user_defined,none,
+      "'distributed actor' resolve-initializer 'init(resolve:using:)' "
+      "cannot be implemented explicitly.",
+      ())
+ERROR(distributed_actor_init_user_defined_must_be_convenience,none,
+      "'distributed actor' initializer %0 must be 'convenience' initializer. "
+      "Distributed actors have an implicitly synthesized designated "
+      "'init(transport:)' local-initializer, which other initializers must delegate to",
+      (DeclName))
+ERROR(distributed_actor_init_must_delegate_to_local_init,none,
+      "'distributed actor' initializer %0 must (directly or indirectly) delegate "
+      "to 'init(transport:)'",
+      (DeclName))
+ERROR(distributed_actor_init_must_not_delegate_to_resolve_init,none,
+      "'distributed actor' initializer %0 cannot delegate to resolve-initializer "
+      "'init(resolve:using:)', as it may result resolving a storageless proxy instance",
+      (DeclName))
+ERROR(distributed_actor_local_var,none,
+      "'distributed' can not be applied to local variables",
+      ())
+ERROR(distributed_actor_property,none,
+      "'distributed' can not be applied to local properties",
+      ())
+ERROR(distributed_actor_storage,none,
+      "'distributed' can not be applied to actor properties; "
+      "Only functions can be 'distributed'",
+      ())
+ERROR(distributed_actor_not_actor,none,
+      "'distributed' can only be applied to 'actor' definitions, "
+      "and distributed actor-isolated async functions",
+      ())
+ERROR(distributed_actor_not_actor_func,none,
+      "'distributed' can only be applied to distributed actor async functions",
+      ())
+ERROR(distributed_actor_func_static,none,
+      "'distributed' functions cannot be 'static'",
+      ())
+ERROR(distributed_actor_func_not_in_distributed_actor,none,
+      "'distributed' function can only be declared within 'distributed actor'",
+      ())
+ERROR(distributed_actor_independent_property_must_be_let,none,
+      "_distributedActorIndependent can be applied to properties, however they must be 'let'",
+      ())
+NOTE(distributed_actor_isolated_property,none,
+      "distributed actor state is only available within the actor instance",
+      ())
+
 ERROR(concurrency_lib_missing,none,
       "missing '%0' declaration, probably because the '_Concurrency' "
       "module was not imported", (StringRef))