[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,