Merge pull request #35959 from DougGregor/enable-concurrent-functions

Author: DougGregor

include/swift/AST/Attr.def

@@ -602,8 +602,8 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(async, Async,
   106)
 
 SIMPLE_DECL_ATTR(concurrent, Concurrent,
-  OnFunc | OnConstructor | OnAccessor | ConcurrencyOnly |
-  ABIStableToAdd | ABIStableToRemove |
+  OnFunc | OnConstructor | OnAccessor |
+  ABIBreakingToAdd | ABIBreakingToRemove |
   APIBreakingToAdd | APIBreakingToRemove,
   107)
 

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

lib/Sema/TypeCheckType.cpp

@@ -2339,17 +2339,7 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
         }
       }
 
-      bool concurrent = false;
-      if (attrs.has(TAK_concurrent)) {
-        if (getASTContext().LangOpts.EnableExperimentalConcurrency) {
-          concurrent = true;
-        } else {
-          diagnoseInvalid(repr, attrs.getLoc(TAK_concurrent),
-                          diag::attr_requires_concurrency,
-                          TypeAttributes::getAttrName(TAK_concurrent),
-                          false);
-        }
-      }
+      bool concurrent = attrs.has(TAK_concurrent);
 
       ty = resolveASTFunctionType(fnRepr, options, rep, /*noescape=*/false,
                                   concurrent, parsedClangFunctionType,

test/IDE/complete_decl_attribute.swift

@@ -71,6 +71,7 @@ struct MyStruct {}
 // KEYWORD2-NEXT:             Keyword/None:                       derivative[#Func Attribute#]; name=derivative
 // KEYWORD2-NEXT:             Keyword/None:                       transpose[#Func Attribute#]; name=transpose
 // KEYWORD2-NEXT:             Keyword/None:                       noDerivative[#Func Attribute#]; name=noDerivative
+// KEYWORD2-NEXT:             Keyword/None:          concurrent[#Func Attribute#]; name=concurrent
 // KEYWORD2-NOT:              Keyword
 // KEYWORD2:                  Decl[Struct]/CurrModule:            MyStruct[#MyStruct#]; name=MyStruct
 // KEYWORD2:                  End completions
@@ -190,6 +191,7 @@ struct _S {
 // ON_METHOD-DAG: Keyword/None:                       differentiable[#Func Attribute#]; name=differentiable
 // ON_METHOD-DAG: Keyword/None:                       derivative[#Func Attribute#]; name=derivative
 // ON_METHOD-DAG: Keyword/None:                       transpose[#Func Attribute#]; name=transpose
+// ON_METHOD-DAG: Keyword/None:                       concurrent[#Func Attribute#]; name=concurrent
 // ON_METHOD-DAG: Keyword/None:                       noDerivative[#Func Attribute#]; name=noDerivative
 // ON_METHOD-NOT: Keyword
 // ON_METHOD: Decl[Struct]/CurrModule:            MyStruct[#MyStruct#]; name=MyStruct
@@ -251,6 +253,7 @@ struct _S {
 // ON_MEMBER_LAST-DAG: Keyword/None:                       derivative[#Declaration Attribute#]; name=derivative
 // ON_MEMBER_LAST-DAG: Keyword/None:                       transpose[#Declaration Attribute#]; name=transpose
 // ON_MEMBER_LAST-DAG: Keyword/None:                       noDerivative[#Declaration Attribute#]; name=noDerivative
+// ON_MEMBER_LAST-DAG: Keyword/None:                       concurrent[#Declaration Attribute#]; name=concurrent
 // ON_MEMBER_LAST-NOT: Keyword
 // ON_MEMBER_LAST: Decl[Struct]/CurrModule:            MyStruct[#MyStruct#]; name=MyStruct
 // ON_MEMBER_LAST-NOT: Decl[PrecedenceGroup]
@@ -300,6 +303,7 @@ func dummy2() {}
 // KEYWORD_LAST-NEXT:             Keyword/None:                       derivative[#Declaration Attribute#]; name=derivative
 // KEYWORD_LAST-NEXT:             Keyword/None:                       transpose[#Declaration Attribute#]; name=transpose
 // KEYWORD_LAST-NEXT:             Keyword/None:                       noDerivative[#Declaration Attribute#]; name=noDerivative
+// KEYWORD_LAST-NEXT:             Keyword/None:                       concurrent[#Declaration Attribute#]; name=concurrent
 // KEYWORD_LAST-NOT:              Keyword
 // KEYWORD_LAST: Decl[Struct]/CurrModule:            MyStruct[#MyStruct#]; name=MyStruct
 // KEYWORD_LAST:                  End completions

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

test/attr/attr_concurrent.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -typecheck -verify %s -enable-experimental-concurrency -enable-experimental-flow-sensitive-concurrent-captures
+// RUN: %target-swift-frontend -typecheck -verify %s -enable-experimental-flow-sensitive-concurrent-captures
 // REQUIRES: concurrency
 
 // Concurrent attribute on a function type.