[Distributed] Only parse distributed when experimental mode enabled

include/swift/AST/DiagnosticsParse.def

@@ -1839,6 +1839,11 @@ 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/Frontend/Frontend.h

@@ -354,9 +354,6 @@ class CompilerInvocation {
   /// imported.
   bool shouldImportSwiftConcurrency() const;
 
-  /// Whether the Distributed support library should be implicitly imported.
-  bool shouldImportSwiftDistributed() const;
-
   /// Performs input setup common to these tools:
   /// sil-opt, sil-func-extractor, sil-llvm-gen, and sil-nm.
   /// Return value includes the buffer so caller can keep it alive.

include/swift/Runtime/RuntimeFunctions.def

@@ -1692,15 +1692,15 @@ FUNCTION(DefaultActorDeallocateResilient,
 // );
 FUNCTION(DistributedActorInitializeRemote,
          swift_distributedActor_remote_initialize, SwiftCC,
-         ConcurrencyAvailability,
+         ConcurrencyAvailability, // TODO(distributed): Introduce DistributedAvailability once shipping somewhere
          RETURNS(OpaquePtrTy),
          ARGS(TypeMetadataPtrTy),
          ATTRS(NoUnwind))
 
-// void swift_distributedActor_destroy(DefaultActor *actor); // TODO: ProxyActor *proxy?
+// void swift_distributedActor_destroy(DefaultActor *actor);
 FUNCTION(DistributedActorDestroy,
          swift_distributedActor_destroy, SwiftCC,
-         ConcurrencyAvailability,
+         ConcurrencyAvailability, // TODO(distributed): Introduce DistributedAvailability once shipping somewhere
          RETURNS(VoidTy),
          ARGS(RefCountedPtrTy),
          ATTRS(NoUnwind))

include/swift/Strings.h

@@ -24,6 +24,8 @@ constexpr static const StringLiteral STDLIB_NAME = "Swift";
 constexpr static const StringLiteral SWIFT_ONONE_SUPPORT = "SwiftOnoneSupport";
 /// The name of the Concurrency module, which supports that extension.
 constexpr static const StringLiteral SWIFT_CONCURRENCY_NAME = "_Concurrency";
+/// The name of the Distributed module, which supports that extension.
+constexpr static const StringLiteral SWIFT_DISTRIBUTED_NAME = "_Distributed";
 /// The name of the SwiftShims module, which contains private stdlib decls.
 constexpr static const StringLiteral SWIFT_SHIMS_NAME = "SwiftShims";
 /// The name of the Builtin module, which contains Builtin functions.

lib/Frontend/Frontend.cpp

@@ -779,12 +779,6 @@ bool CompilerInvocation::shouldImportSwiftConcurrency() const {
         FrontendOptions::ParseInputMode::SwiftModuleInterface;
 }
 
-bool CompilerInvocation::shouldImportSwiftDistributed() const {
-  return getLangOptions().EnableExperimentalDistributed &&
-      getFrontendOptions().InputMode !=
-        FrontendOptions::ParseInputMode::SwiftModuleInterface;
-}
-
 /// Implicitly import the SwiftOnoneSupport module in non-optimized
 /// builds. This allows for use of popular specialized functions
 /// from the standard library, which makes the non-optimized builds

lib/Parse/ParseDecl.cpp

@@ -1611,6 +1611,14 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
     DiscardAttribute = true;
   }
 
+  // If this attribute is only permitted when distributed is enabled, reject it.
+  if (DeclAttribute::isDistributedOnly(DK) &&
+      !shouldParseExperimentalDistributed()) {
+    diagnose(Loc, diag::attr_requires_distributed, AttrName,
+             DeclAttribute::isDeclModifier(DK));
+    DiscardAttribute = true;
+  }
+
   if (Context.LangOpts.Target.isOSBinFormatCOFF()) {
     if (DK == DAK_WeakLinked) {
       diagnose(Loc, diag::attr_unsupported_on_target, AttrName,

test/Distributed/distributed_actor_is_experimental.swift

@@ -7,30 +7,37 @@ actor SomeActor {}
 
 @available(SwiftStdlib 5.5, *)
 distributed actor DA {}
-// expected-error@-1{{'_Distributed' module not imported, required for 'distributed actor'}}
+// expected-error@-1{{'distributed' modifier is only valid when experimental distributed support is enabled}}
 
 @available(SwiftStdlib 5.5, *)
-distributed actor class DAC {} // expected-error{{distributed' can only be applied to 'actor' definitions, and distributed actor-isolated async functions}}
-// expected-error@-1{{keyword 'class' cannot be used as an identifier here}}
+distributed actor class DAC {}
+// expected-error@-1{{'distributed' modifier is only valid when experimental distributed support is enabled}}
+// expected-error@-2{{keyword 'class' cannot be used as an identifier here}}
 
 actor A {
   func normal() async {}
-  distributed func dist() {} // expected-error{{'distributed' function can only be declared within 'distributed actor'}}
-  distributed func distAsync() async {} // expected-error{{'distributed' function can only be declared within 'distributed actor'}}
+  distributed func dist() {}
+  // expected-error@-1{{'distributed' modifier is only valid when experimental distributed support is enabled}}
+  distributed func distAsync() async {}
+  // expected-error@-1{{'distributed' modifier is only valid when experimental distributed support is enabled}}
 
-  distributed var neverOk: String { // expected-error{{'distributed' modifier cannot be applied to this declaration}}
+  distributed var neverOk: String {
+    // expected-error@-1{{'distributed' modifier is only valid when experimental distributed support is enabled}}
     "vars are not allowed to be distributed *ever* anyway"
   }
 }
 
 @available(SwiftStdlib 5.5, *)
 distributed actor DA2 {
-  // expected-error@-1{{'_Distributed' module not imported, required for 'distributed actor'}}
+  // expected-error@-1{{'distributed' modifier is only valid when experimental distributed support is enabled}}
   func normal() async {}
   distributed func dist() {}
+  // expected-error@-1{{'distributed' modifier is only valid when experimental distributed support is enabled}}
   distributed func distAsync() async {}
+  // expected-error@-1{{'distributed' modifier is only valid when experimental distributed support is enabled}}
 
-  distributed var neverOk: String { // expected-error{{'distributed' modifier cannot be applied to this declaration}}
+  distributed var neverOk: String {
+    // expected-error@-1{{'distributed' modifier is only valid when experimental distributed support is enabled}}
     "vars are not allowed to be distributed *ever* anyway"
   }
 }

test/Distributed/distributed_actor_is_experimental_enabled_missing_import.swift

@@ -0,0 +1,37 @@
+// RUN: %target-typecheck-verify-swift -disable-availability-checking -enable-experimental-distributed
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+actor SomeActor {}
+
+@available(SwiftStdlib 5.5, *)
+distributed actor DA {}
+// expected-error@-1{{'_Distributed' module not imported, required for 'distributed actor'}}
+
+@available(SwiftStdlib 5.5, *)
+distributed actor class DAC {}
+// expected-error@-1{{distributed' can only be applied to 'actor' definitions, and distributed actor-isolated async functions}}
+// expected-error@-2{{keyword 'class' cannot be used as an identifier here}}
+
+actor A {
+  func normal() async {}
+  distributed func dist() {} // expected-error{{'distributed' function can only be declared within 'distributed actor'}}
+  distributed func distAsync() async {} // expected-error{{'distributed' function can only be declared within 'distributed actor'}}
+
+  distributed var neverOk: String { // expected-error{{'distributed' modifier cannot be applied to this declaration}}
+    "vars are not allowed to be distributed *ever* anyway"
+  }
+}
+
+@available(SwiftStdlib 5.5, *)
+distributed actor DA2 {
+  // expected-error@-1{{'_Distributed' module not imported, required for 'distributed actor'}}
+  func normal() async {}
+  distributed func dist() {}
+  distributed func distAsync() async {}
+
+  distributed var neverOk: String { // expected-error{{'distributed' modifier cannot be applied to this declaration}}
+    "vars are not allowed to be distributed *ever* anyway"
+  }
+}
+

test/Distributed/distributed_actor_is_experimental_with_import.swift

@@ -0,0 +1,10 @@
+// RUN: %target-typecheck-verify-swift -disable-availability-checking
+// ^^^^ notice the, on purpose, missing '-enable-experimental-distributed'
+// REQUIRES: concurrency
+// REQUIRES: distributed
+
+import _Distributed
+
+@available(macOS 12.0, *)
+distributed actor A {}
+// expected-error@-1{{'distributed' modifier is only valid when experimental distributed support is enabled}}

tools/sil-opt/SILOpt.cpp

@@ -415,6 +415,8 @@ int main(int argc, char **argv) {
   }
   Invocation.getLangOptions().EnableExperimentalConcurrency =
     EnableExperimentalConcurrency;
+  Invocation.getLangOptions().EnableExperimentalDistributed =
+    EnableExperimentalDistributed;
 
   Invocation.getLangOptions().EnableObjCInterop =
     EnableObjCInterop ? true :