Define a feature for @Concurrent functions.

Author: DougGregor

include/swift/Basic/Features.def

@@ -38,5 +38,6 @@ LANGUAGE_FEATURE(StaticAssert, 0, "#assert", langOpts.EnableExperimentalStaticAs
 LANGUAGE_FEATURE(AsyncAwait, 296, "async/await", true)
 LANGUAGE_FEATURE(MarkerProtocol, 0, "@_marker protocol", true)
 LANGUAGE_FEATURE(Actors, 0, "actors", langOpts.EnableExperimentalConcurrency)
+LANGUAGE_FEATURE(ConcurrentFunctions, 0, "@concurrent functions", true)
 
 #undef LANGUAGE_FEATURE

lib/AST/ASTPrinter.cpp

@@ -2509,6 +2509,32 @@ static bool usesFeatureActors(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureConcurrentFunctions(Decl *decl) {
+  if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
+    if (func->isConcurrent())
+      return true;
+  }
+
+  // Check for concurrent functions in the types of declarations.
+  if (auto value = dyn_cast<ValueDecl>(decl)) {
+    if (Type type = value->getInterfaceType()) {
+      bool hasConcurrent = type.findIf([](Type type) {
+        if (auto fnType = type->getAs<AnyFunctionType>()) {
+          if (fnType->isConcurrent())
+            return true;
+        }
+
+        return false;
+      });
+
+      if (hasConcurrent)
+        return true;
+    }
+  }
+
+  return false;
+}
+
 /// Determine the set of "new" features used on a given declaration.
 ///
 /// Note: right now, all features we check for are "new". At some point, we'll

test/ModuleInterface/features.swift

@@ -72,6 +72,11 @@ extension OldSchool: UnsafeConcurrentValue { }
 // CHECK-NEXT: #endif
 public func runSomethingSomewhere(body: () async -> Void) { }
 
+// CHECK: #if compiler(>=5.3) && $ConcurrentFunctions
+// CHECK-NEXT: func runSomethingConcurrently(body: @concurrent () -> 
+// CHECK-NEXT: #endif
+public func runSomethingConcurrently(body: @concurrent () -> Void) { }
+
 // CHECK: #if compiler(>=5.3) && $Actors
 // CHECK-NEXT: func stage
 // CHECK-NEXT: #endif