[Distributed] Only parse distributed when experimentla mode enabled

Author: ktoso

include/swift/AST/ASTContext.h

@@ -753,6 +753,9 @@ class ASTContext final {
   /// Get the runtime availability of support for concurrency.
   AvailabilityContext getConcurrencyAvailability();
 
+  /// Get the runtime availability of support for distributed actors.
+  AvailabilityContext getDistributedAvailability();
+
   /// Get the runtime availability of support for differentiation.
   AvailabilityContext getDifferentiationAvailability();
 

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.
@@ -536,6 +533,10 @@ class CompilerInstance {
   /// i.e. if it can be found.
   bool canImportSwiftConcurrency() const;
 
+  /// Whether the Distributed actors support library can be imported
+  /// i.e. if it can be found.
+  bool canImportSwiftDistributed() const;
+
   /// Gets the SourceFile which is the primary input for this CompilerInstance.
   /// \returns the primary SourceFile, or nullptr if there is no primary input;
   /// if there are _multiple_ primary inputs, fails with an assertion.

include/swift/Runtime/RuntimeFunctions.def

@@ -1692,15 +1692,15 @@ FUNCTION(DefaultActorDeallocateResilient,
 // );
 FUNCTION(DistributedActorInitializeRemote,
          swift_distributedActor_remote_initialize, SwiftCC,
-         ConcurrencyAvailability,
+         DistributedAvailability,
          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,
+         DistributedAvailability,
          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/AST/Availability.cpp

@@ -330,6 +330,10 @@ AvailabilityContext ASTContext::getConcurrencyAvailability() {
   return getSwift55Availability();
 }
 
+AvailabilityContext ASTContext::getDistributedAvailability() {
+  return getSwift55Availability(); // FIXME(distributed): getSwiftFutureAvailability perhaps? The module is not shipping in any release so far so it does not matter for real though.
+}
+
 AvailabilityContext ASTContext::getDifferentiationAvailability() {
   return getSwiftFutureAvailability();
 }

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
@@ -825,6 +819,11 @@ bool CompilerInstance::canImportSwiftConcurrency() const {
       {getASTContext().getIdentifier(SWIFT_CONCURRENCY_NAME), SourceLoc()});
 }
 
+bool CompilerInstance::canImportSwiftDistributed() const {
+  return getASTContext().canImportModule(
+      {getASTContext().getIdentifier(SWIFT_DISTRIBUTED_NAME), SourceLoc()});
+}
+
 ImplicitImportInfo CompilerInstance::getImplicitImportInfo() const {
   auto &frontendOpts = Invocation.getFrontendOptions();
 

lib/IRGen/IRGenModule.cpp

@@ -786,6 +786,14 @@ namespace RuntimeConstants {
     return RuntimeAvailability::AlwaysAvailable;
   }
 
+  RuntimeAvailability DistributedAvailability(ASTContext &context) {
+    auto featureAvailability = context.getDistributedAvailability();
+    if (!isDeploymentAvailabilityContainedIn(context, featureAvailability)) {
+      return RuntimeAvailability::ConditionallyAvailable;
+    }
+    return RuntimeAvailability::AlwaysAvailable;
+  }
+
   RuntimeAvailability DifferentiationAvailability(ASTContext &context) {
     auto featureAvailability = context.getDifferentiationAvailability();
     if (!isDeploymentAvailabilityContainedIn(context, featureAvailability)) {

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,

lib/Sema/TypeCheckAvailability.cpp

@@ -1702,6 +1702,24 @@ void TypeChecker::checkConcurrencyAvailability(SourceRange ReferenceRange,
   }
 }
 
+void TypeChecker::checkDistributedAvailability(SourceRange ReferenceRange,
+                                               const DeclContext *ReferenceDC) {
+  // Check the availability of concurrency runtime support.
+  ASTContext &ctx = ReferenceDC->getASTContext();
+  if (ctx.LangOpts.DisableAvailabilityChecking)
+    return;
+
+  auto runningOS =
+    TypeChecker::overApproximateAvailabilityAtLocation(
+      ReferenceRange.Start, ReferenceDC);
+  auto availability = ctx.getDistributedAvailability();
+  if (!runningOS.isContainedIn(availability)) {
+    diagnosePotentialConcurrencyUnavailability(
+      ReferenceRange, ReferenceDC,
+      UnavailabilityReason::requiresVersionRange(availability.getOSVersion()));
+  }
+}
+
 void TypeChecker::diagnosePotentialUnavailability(
     const ValueDecl *D, SourceRange ReferenceRange,
     const DeclContext *ReferenceDC,

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2418,9 +2418,11 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
 
     TypeChecker::checkDeclAttributes(CD);
 
-    if (CD->isActor())
+    if (CD->isActor()) {
       TypeChecker::checkConcurrencyAvailability(CD->getLoc(), CD);
-
+      if (CD->isDistributedActor())
+        TypeChecker::checkDistributedAvailability(CD->getLoc(), CD);
+    }
     for (Decl *Member : CD->getABIMembers())
       visit(Member);
 

lib/Sema/TypeChecker.h

@@ -1026,6 +1026,9 @@ void checkDistributedActor(ClassDecl *decl);
 void checkConcurrencyAvailability(SourceRange ReferenceRange,
                                   const DeclContext *ReferenceDC);
 
+void checkDistributedAvailability(SourceRange ReferenceRange,
+                                  const DeclContext *ReferenceDC);
+
 /// Emits a diagnostic for a reference to a storage accessor that is
 /// potentially unavailable.
 void diagnosePotentialAccessorUnavailability(

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 :