Merge pull request #41233 from ktoso/wip-distributed-get-only-properties

Author: swift-ci

include/swift/AST/Attr.def

@@ -651,7 +651,7 @@ SIMPLE_DECL_ATTR(_inheritActorContext, InheritActorContext,
 // 117 was 'spawn' and is now unused
 
 CONTEXTUAL_SIMPLE_DECL_ATTR(distributed, DistributedActor,
-  DeclModifier | OnClass | OnFunc |
+  DeclModifier | OnClass | OnFunc | OnVar |
   DistributedOnly |
   ABIBreakingToAdd | ABIBreakingToRemove |
   APIBreakingToAdd | APIBreakingToRemove,

include/swift/AST/Decl.h

@@ -144,6 +144,7 @@ enum class DescriptiveDeclKind : uint8_t {
   Property,
   StaticProperty,
   ClassProperty,
+  DistributedProperty,
   InfixOperator,
   PrefixOperator,
   PostfixOperator,
@@ -5240,6 +5241,9 @@ class VarDecl : public AbstractStorageDecl {
   /// Is this an "async let" property?
   bool isAsyncLet() const;
 
+  /// Does this have a 'distributed' modifier?
+  bool isDistributed() const;
+
   /// Is this a stored property that will _not_ trigger any user-defined code
   /// upon any kind of access?
   bool isOrdinaryStoredProperty() const;

include/swift/AST/DiagnosticsSema.def

@@ -4496,8 +4496,8 @@ ERROR(actor_isolated_non_self_reference,none,
         "from the main actor|from a non-isolated context}3",
         (DescriptiveDeclKind, DeclName, unsigned, unsigned, Type))
 ERROR(distributed_actor_isolated_non_self_reference,none,
-      "distributed actor-isolated %0 %1 can only be referenced inside the "
-      "distributed actor",
+      "distributed actor-isolated %0 %1 can not be accessed from a "
+      "non-isolated context",
       (DescriptiveDeclKind, DeclName))
 ERROR(distributed_actor_needs_explicit_distributed_import,none,
       "'_Distributed' module not imported, required for 'distributed actor'",
@@ -4569,11 +4569,11 @@ ERROR(distributed_actor_isolated_method,none,
       "only 'distributed' instance methods can be called on a potentially remote distributed actor",
       ())
 ERROR(distributed_actor_func_param_not_codable,none,
-      "parameter '%0' of type %1 in %2 does not conform to '%3'",
+      "parameter '%0' of type %1 in %2 does not conform to serialization requirement '%3'",
       (StringRef, Type, DescriptiveDeclKind, StringRef))
-ERROR(distributed_actor_func_result_not_codable,none,
-      "result type %0 of %1 does not conform to '%2'",
-      (Type, DescriptiveDeclKind, StringRef))
+ERROR(distributed_actor_target_result_not_codable,none,
+      "result type %0 of %1 %2 does not conform to serialization requirement '%3'",
+      (Type, DescriptiveDeclKind, Identifier, StringRef))
 ERROR(distributed_actor_remote_func_implemented_manually,none,
       "distributed instance method's %0 remote counterpart %1 cannot not be implemented manually.",
       (Identifier, Identifier))
@@ -4764,9 +4764,18 @@ ERROR(distributed_actor_user_defined_special_property,none,
       "property %0 cannot be defined explicitly, as it conflicts with "
       "distributed actor synthesized stored property",
       (DeclName))
+ERROR(distributed_property_can_only_be_computed_get_only,none,
+      "'distributed' computed property %0 cannot have setter",
+      (DeclName))
+ERROR(distributed_property_cannot_be_static,none,
+      "'distributed' property %0 cannot be 'static'",
+      (DeclName))
+ERROR(distributed_property_can_only_be_computed,none,
+      "%0 %1 cannot be 'distributed', only computed properties can",
+      (DescriptiveDeclKind, DeclName))
 NOTE(distributed_actor_isolated_property,none,
-      "distributed actor state is only available within the actor instance", // TODO: reword in terms of isolation
-      ())
+      "access to %0 %1 is only permitted within distributed actor %2",
+      (DescriptiveDeclKind, DeclName, DeclName))
 
 ERROR(concurrency_lib_missing,none,
       "missing '%0' declaration, probably because the '_Concurrency' "

lib/AST/Decl.cpp

@@ -191,8 +191,13 @@ DescriptiveDeclKind Decl::getDescriptiveKind() const {
      auto var = cast<VarDecl>(this);
      switch (var->getCorrectStaticSpelling()) {
      case StaticSpellingKind::None:
-       if (var->getDeclContext()->isTypeContext())
+       if (var->getDeclContext()->isTypeContext()) {
+         if (var->isDistributed() && !var->isLet()) {
+           return DescriptiveDeclKind::DistributedProperty;
+         }
+
          return DescriptiveDeclKind::Property;
+       }
        return var->isLet() ? DescriptiveDeclKind::Let
                            : DescriptiveDeclKind::Var;
      case StaticSpellingKind::KeywordStatic:
@@ -299,6 +304,7 @@ StringRef Decl::getDescriptiveKindName(DescriptiveDeclKind K) {
   ENTRY(Property, "property");
   ENTRY(StaticProperty, "static property");
   ENTRY(ClassProperty, "class property");
+  ENTRY(DistributedProperty, "distributed property");
   ENTRY(PrecedenceGroup, "precedence group");
   ENTRY(InfixOperator, "infix operator");
   ENTRY(PrefixOperator, "prefix operator");
@@ -6304,6 +6310,10 @@ bool VarDecl::isAsyncLet() const {
   return getAttrs().hasAttribute<AsyncAttr>();
 }
 
+bool VarDecl::isDistributed() const {
+  return getAttrs().hasAttribute<DistributedActorAttr>();
+}
+
 bool VarDecl::isOrdinaryStoredProperty() const {
   // we assume if it hasAttachedPropertyWrapper, it has no storage.
   //

lib/SILGen/SILGenDistributed.cpp

@@ -1154,15 +1154,17 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
           subTypes.push_back(paramTy);
 
           // --- Codable: Decodable
-          auto decodableRequirementTy =
-              ctx.getProtocol(KnownProtocolKind::Decodable); // FIXME: actually use SerializatioNRequirement
+          auto decodableRequirementTy = ctx.getProtocol(
+              KnownProtocolKind::Decodable); // FIXME(distributed): actually use
+                                             // SerializationRequirement
           auto paramDecodableTypeConfRef = module->lookupConformance(
               paramTy, decodableRequirementTy);
           subConformances.push_back(paramDecodableTypeConfRef);
 
           // --- Codable: Encodable
           auto encodableRequirementTy = ctx.getProtocol(
-              KnownProtocolKind::Encodable); // FIXME: actually use SerializatioNRequirement
+              KnownProtocolKind::Encodable); // FIXME(distributed): actually use
+                                             // SerializationRequirement
           auto paramEncodableTypeConfRef = module->lookupConformance(
               paramTy, encodableRequirementTy);
           subConformances.push_back(paramEncodableTypeConfRef);

lib/Sema/TypeCheckAttr.cpp

@@ -5548,9 +5548,14 @@ void AttributeChecker::visitDistributedActorAttr(DistributedActorAttr *attr) {
 
   // distributed can be applied to actor definitions and their methods
   if (auto varDecl = dyn_cast<VarDecl>(D)) {
-    // distributed can not be applied to stored properties
-    diagnoseAndRemoveAttr(attr, diag::distributed_actor_property);
-    return;
+    if (varDecl->isDistributed()) {
+      if (checkDistributedActorProperty(varDecl, /*diagnose=*/true))
+        return;
+    } else {
+      // distributed can not be applied to stored properties
+      diagnoseAndRemoveAttr(attr, diag::distributed_actor_property);
+      return;
+    }
   }
 
   // distributed can only be declared on an `actor`

lib/Sema/TypeCheckConcurrency.cpp

@@ -1953,16 +1953,18 @@ namespace {
     void noteIsolatedActorMember(ValueDecl *decl, Expr *context) {
       // detect if it is a distributed actor, to provide better isolation notes
 
-      auto isDistributedActor = false;
-      if (auto nominal = decl->getDeclContext()->getSelfNominalTypeDecl())
-        isDistributedActor = nominal->isDistributedActor();
+      auto nominal = decl->getDeclContext()->getSelfNominalTypeDecl();
+      bool isDistributedActor = false;
+      if (nominal) isDistributedActor = nominal->isDistributedActor();
 
       // FIXME: Make this diagnostic more sensitive to the isolation context of
       // the declaration.
       if (isDistributedActor) {
-        if (dyn_cast<VarDecl>(decl)) {
+        if (isa<VarDecl>(decl)) {
           // Distributed actor properties are never accessible externally.
-          decl->diagnose(diag::distributed_actor_isolated_property);
+          decl->diagnose(diag::distributed_actor_isolated_property,
+                         decl->getDescriptiveKind(), decl->getName(),
+                         nominal->getName());
         } else {
           // it's a function or subscript
           decl->diagnose(diag::note_distributed_actor_isolated_method,
@@ -4705,9 +4707,9 @@ bool swift::isPotentiallyIsolatedActor(
 
   if (var->getName().str().equals("__secretlyKnownToBeLocal")) {
     // FIXME(distributed): we did a dynamic check and know that this actor is
-    // local,
-    //  but we can't express that to the type system; the real implementation
-    //  will have to mark 'self' as "known to be local" after an is-local check.
+    //   local, but we can't express that to the type system; the real
+    //   implementation will have to mark 'self' as "known to be local" after
+    //   an is-local check.
     return true;
   }