[Distributed] Fix dist property being implicitly async after refactor (#61995)

Author: ktoso

include/swift/AST/DiagnosticsSema.def

@@ -4981,6 +4981,9 @@ ERROR(distributed_property_accessor_only_get_can_be_distributed,none,
 NOTE(distributed_actor_isolated_property,none,
       "access to %0 %1 is only permitted within distributed actor %2",
       (DescriptiveDeclKind, DeclName, DeclName))
+NOTE(distributed_actor_synchronous_access_distributed_computed_property,none,
+      "access to %0 %1 from outside the distributed actor %2 must be asynchronous",
+      (DescriptiveDeclKind, DeclName, DeclName))
 
 ERROR(concurrency_lib_missing,none,
       "missing '%0' declaration, probably because the '_Concurrency' "

lib/Sema/TypeCheckConcurrency.cpp

@@ -1303,11 +1303,19 @@ static void noteIsolatedActorMember(
   // FIXME: Make this diagnostic more sensitive to the isolation context of
   // the declaration.
   if (isDistributedActor) {
-    if (isa<VarDecl>(decl)) {
-      // Distributed actor properties are never accessible externally.
-      decl->diagnose(diag::distributed_actor_isolated_property,
-                     decl->getDescriptiveKind(), decl->getName(),
-                     nominal->getName());
+    if (auto varDecl = dyn_cast<VarDecl>(decl)) {
+      if (varDecl->isDistributed()) {
+        // This is an attempt to access a `distributed var` synchronously, so offer a more detailed error
+        decl->diagnose(diag::distributed_actor_synchronous_access_distributed_computed_property,
+                       decl->getDescriptiveKind(), decl->getName(),
+                       nominal->getName());
+      } else {
+        // Distributed actor properties are never accessible externally.
+        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,

lib/Sema/TypeCheckEffects.cpp

@@ -2476,15 +2476,30 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
         effects.push_back(EffectKind::Async);
       }
 
-      checkThrowAsyncSite(E, getter->hasThrows(),
+      bool requiresTry = getter->hasThrows();
+      checkThrowAsyncSite(E, requiresTry,
                           Classification::forEffect(effects,
                                   ConditionalEffectKind::Always,
                                   getKindOfEffectfulProp(member)));
 
-    } else if (E->isImplicitlyAsync()) {
-      checkThrowAsyncSite(E, /*requiresTry=*/false,
-            Classification::forUnconditional(EffectKind::Async,
-                                             getKindOfEffectfulProp(member)));
+    } else {
+      EffectList effects;
+      bool requiresTry = false;
+      if (E->isImplicitlyAsync()) {
+        effects.push_back(EffectKind::Async);
+      }
+      if (E->isImplicitlyThrows()) {
+        // E.g. it may be a distributed computed property, accessed across actors.
+        effects.push_back(EffectKind::Throws);
+        requiresTry = true;
+      }
+
+      if (!effects.empty()) {
+        checkThrowAsyncSite(E, requiresTry,
+                            Classification::forEffect(effects,
+                                                      ConditionalEffectKind::Always,
+                                                      getKindOfEffectfulProp(member)));
+      }
     }
 
     return ShouldRecurse;

test/Distributed/distributed_actor_isolation.swift

@@ -131,6 +131,7 @@ distributed actor DistributedActor_1 {
 
   func test_inside() async throws {
     _ = self.name
+    _ = self.computed
     _ = self.computedMutable
 
     _ = try await self.distInt()

test/Distributed/distributed_property_must_be_throws.swift

@@ -0,0 +1,37 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend-emit-module -emit-module-path %t/FakeDistributedActorSystems.swiftmodule -module-name FakeDistributedActorSystems -disable-availability-checking %S/Inputs/FakeDistributedActorSystems.swift
+// RUN: %target-swift-frontend -typecheck -verify -verify-ignore-unknown -disable-availability-checking -I %t 2>&1 %s
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+import Distributed
+import FakeDistributedActorSystems
+
+let globalActorSystem = LocalTestingDistributedActorSystem()
+
+distributed actor MyDistributedActor {
+  typealias ActorSystem = LocalTestingDistributedActorSystem
+  distributed var distributedProperty: Set<Int> { [] }
+  distributed var accessMe: Set<Int> { [] }
+  // expected-note@-1{{access to distributed property 'accessMe' from outside the distributed actor 'MyDistributedActor' must be asynchronous}}
+}
+
+func test(da: MyDistributedActor) async throws {
+  _ = await da.distributedProperty // expected-error{{property access can throw but is not marked with 'try'}}
+  // expected-note@-1{{did you mean to use 'try'?}}
+  // expected-note@-2{{did you mean to handle error as optional value?}}
+  // expected-note@-3{{did you mean to disable error propagation?}}
+
+  _ = try da.distributedProperty // expected-error{{expression is 'async' but is not marked with 'await'}}
+  // expected-note@-1{{property access is 'async'}}
+
+  _ = try await da.distributedProperty // ok, implicitly async + throws
+}
+
+func testSyncFunc(da: MyDistributedActor) throws {
+  _ = da.accessMe // expected-error{{actor-isolated distributed property 'accessMe' can not be referenced from a non-isolated context}}
+  // expected-error@-1{{property access can throw but is not marked with 'try'}}
+  // expected-note@-2{{did you mean to use 'try'?}}
+  // expected-note@-3{{did you mean to handle error as optional value?}}
+  // expected-note@-4{{did you mean to disable error propagation?}}
+}