Merge pull request #4354 from swiftwasm/main

Author: MaxDesiatov

CHANGELOG.md

@@ -5,6 +5,36 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
 
 ## Swift 5.7
 
+* [SE-0336][]:
+
+It is now possible to declare `distributed actor` and `distributed func`s inside of them.
+
+Distributed actors provide stronger isolation guarantees than "local" actors, and enable additional checks to be made on return types and parameters of distributed methods, e.g. checking if they conform to `Codable`. Distributed methods can be called on "remote" references of distributed actors, turning those invocations into remote procedure calls, by means of pluggable and user extensible distributed actor system implementations. 
+
+Swift does not provide any specific distributed actor system by itself, however, packages in the ecosystem fulfil the role of providing those implementations.
+
+```swift
+distributed actor Greeter { 
+  var greetingsSent = 0
+  
+  distributed func greet(name: String) -> String {
+    greetingsSent += 1
+    return "Hello, \(name)!"
+  }
+}
+
+func talkTo(greeter: Greeter) async throws {
+  // isolation of distributed actors is stronger, it is impossible to refer to
+  // any stored properties of distributed actors from outside of them:
+  greeter.greetingsSent // distributed actor-isolated property 'name' can not be accessed from a non-isolated context
+  
+  // remote calls are implicitly throwing and async, 
+  // to account for the potential networking involved:
+  let greeting = try await greeter.greet(name: "Alice")
+  print(greeting) // Hello, Alice!
+}
+```
+
 * The compiler now emits a warning when a non-final class conforms to a protocol that imposes a same-type requirement between `Self` and an associated type. This is because such a requirement makes the conformance unsound for subclasses.
 
 For example, Swift 5.6 would allow the following code, which at runtime would construct an instanec of `C` and not `SubC` as expected:
@@ -9034,6 +9064,7 @@ Swift 1.0
 [SE-0337]: <https://github.com/apple/swift-evolution/blob/main/proposals/0337-support-incremental-migration-to-concurrency-checking.md>
 [SE-0335]: <https://github.com/apple/swift-evolution/blob/main/proposals/0335-existential-any.md>
 [SE-0341]: <https://github.com/apple/swift-evolution/blob/main/proposals/0341-opaque-parameters.md>
+[SE-0336]: <https://github.com/apple/swift-evolution/blob/main/proposals/0336-distributed-actor-isolation.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

include/swift/AST/Decl.h

@@ -6315,7 +6315,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   ///         diagnosed errors during type checking.
   FuncDecl *getDistributedThunk() const;
 
-  /// Returns 'true' if the function has the @c @_backDeploy attribute.
+  /// Returns 'true' if the function has (or inherits) the @c @_backDeploy
+  /// attribute.
   bool isBackDeployed() const;
 
   PolymorphicEffectKind getPolymorphicEffectKind(EffectKind kind) const;

include/swift/AST/DiagnosticsParse.def

@@ -1887,11 +1887,6 @@ ERROR(attr_requires_concurrency, none,
       "concurrency is enabled",
       (StringRef, bool))
 
-ERROR(attr_requires_distributed, none,
-      "'%0' %select{attribute|modifier}1 is only valid when experimental "
-      "distributed support is enabled",
-      (StringRef, bool))
-
 //------------------------------------------------------------------------------
 // MARK: syntax parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/AST/DiagnosticsSema.def

@@ -6320,5 +6320,9 @@ ERROR(attr_incompatible_with_back_deploy,none,
       "'%0' cannot be applied to a back deployed %1",
       (DeclAttribute, DescriptiveDeclKind))
 
+ERROR(back_deploy_not_on_coroutine,none,
+      "'%0' is not supported on coroutine %1",
+      (DeclAttribute, DescriptiveDeclKind))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DistributedDecl.h

@@ -106,6 +106,7 @@ getDistributedSerializationRequirements(
 llvm::SmallPtrSet<ProtocolDecl *, 2>
 extractDistributedSerializationRequirements(
     ASTContext &C, ArrayRef<Requirement> allRequirements);
+
 }
 
 #endif /* SWIFT_DECL_TYPECHECKDISTRIBUTED_H */

include/swift/AST/KnownIdentifiers.def

@@ -109,6 +109,7 @@ IDENTIFIER(keyPath)
 IDENTIFIER(makeIterator)
 IDENTIFIER(makeAsyncIterator)
 IDENTIFIER(nestedContainer)
+IDENTIFIER(isEmpty)
 IDENTIFIER(Iterator)
 IDENTIFIER(AsyncIterator)
 IDENTIFIER(load)
@@ -124,6 +125,7 @@ IDENTIFIER(oldValue)
 IDENTIFIER(Optional)
 IDENTIFIER_(OptionalNilComparisonType)
 IDENTIFIER(parameter)
+IDENTIFIER(popFirst)
 IDENTIFIER(projected)
 IDENTIFIER(projectedValue)
 IDENTIFIER(Protocol)
@@ -149,7 +151,6 @@ IDENTIFIER(Type)
 IDENTIFIER(type)
 IDENTIFIER(typeMismatch)
 IDENTIFIER(underlyingError)
-IDENTIFIER(unsafelyUnwrapped)
 IDENTIFIER(Value)
 IDENTIFIER(value)
 IDENTIFIER_WITH_NAME(value_, "_value")

include/swift/AST/KnownStdlibTypes.def

@@ -49,6 +49,7 @@ KNOWN_STDLIB_TYPE_DECL(String, NominalTypeDecl, 0)
 KNOWN_STDLIB_TYPE_DECL(StaticString, NominalTypeDecl, 0)
 KNOWN_STDLIB_TYPE_DECL(Substring, NominalTypeDecl, 0)
 KNOWN_STDLIB_TYPE_DECL(Array, NominalTypeDecl, 1)
+KNOWN_STDLIB_TYPE_DECL(ArraySlice, NominalTypeDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(_ContiguousArrayStorage, ClassDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(Set, NominalTypeDecl, 1)
 KNOWN_STDLIB_TYPE_DECL(Sequence, NominalTypeDecl, 1)

include/swift/AST/SwiftNameTranslation.h

@@ -54,6 +54,16 @@ namespace objc_translation {
                        bool checkParent = true);
 
 } // end namespace objc_translation
+
+namespace cxx_translation {
+
+/// Returns true if the given value decl D is visible to C++ of its
+/// own accord (i.e. without considering its context)
+bool isVisibleToCxx(const ValueDecl *VD, AccessLevel minRequiredAccess,
+                    bool checkParent = true);
+
+} // end namespace cxx_translation
+
 } // end namespace swift
 
 #endif

include/swift/AST/TypeCheckRequests.h

@@ -1039,6 +1039,30 @@ class IsDistributedActorRequest :
     bool isCached() const { return true; }
 };
 
+/// Retrieve the implicit conformance for the given distributed actor type to
+/// the Codable protocol protocol.
+///
+/// Similar to 'GetImplicitSendableRequest'.
+class GetDistributedActorImplicitCodableRequest :
+    public SimpleRequest<GetDistributedActorImplicitCodableRequest,
+                         NormalProtocolConformance *(NominalTypeDecl *, KnownProtocolKind),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  NormalProtocolConformance *evaluate(
+      Evaluator &evaluator,
+      NominalTypeDecl *nominal,
+      KnownProtocolKind protoKind) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 /// Obtain the 'remoteCall' function of a 'DistributedActorSystem'.
 class GetDistributedActorSystemRemoteCallFunctionRequest :
     public SimpleRequest<GetDistributedActorSystemRemoteCallFunctionRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -107,6 +107,9 @@ SWIFT_REQUEST(TypeChecker, IsDefaultActorRequest,
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsDistributedActorRequest, bool(NominalTypeDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, GetDistributedActorImplicitCodableRequest,
+               NormalProtocolConformance *(NominalTypeDecl *, KnownProtocolKind),
+               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetDistributedActorSystemRemoteCallFunctionRequest,
               AbstractFunctionDecl *(NominalTypeDecl *, bool),
               Cached, NoLocationInfo)