[Frontend] Add a feature to guard use of @concurrent and nonisolated(nonsending) in swift interface files

Author: xedin

include/swift/Basic/Features.def

@@ -254,6 +254,7 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(MemorySafetyAttributes, 458, "@unsafe attribute")
 LANGUAGE_FEATURE(ValueGenerics, 452, "Value generics feature (integer generics)")
 LANGUAGE_FEATURE(RawIdentifiers, 451, "Raw identifiers")
 LANGUAGE_FEATURE(SendableCompletionHandlers, 463, "Objective-C completion handler parameters are imported as @Sendable")
+LANGUAGE_FEATURE(AsyncExecutionBehaviorAttributes, 0, "@concurrent and nonisolated(nonsending)")
 
 // Swift 6
 UPCOMING_FEATURE(ConciseMagicFile, 274, 6)

lib/AST/FeatureSet.cpp

@@ -502,6 +502,57 @@ static bool usesFeatureBuiltinEmplaceTypedThrows(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureAsyncExecutionBehaviorAttributes(Decl *decl) {
+  // Explicit `@concurrent` attribute on the declaration.
+  if (decl->getAttrs().hasAttribute<ConcurrentAttr>())
+    return true;
+
+  // Explicit `nonisolated(nonsending)` attribute on the declaration.
+  if (auto *nonisolated = decl->getAttrs().getAttribute<NonisolatedAttr>()) {
+    if (nonisolated->isNonSending())
+      return true;
+  }
+
+  auto hasCallerIsolatedAttr = [](TypeRepr *R) {
+    if (!R)
+      return false;
+
+    return R->findIf([](TypeRepr *repr) {
+      if (isa<CallerIsolatedTypeRepr>(repr))
+        return true;
+
+      // We don't check for @concurrent here because it's
+      // not printed in type positions since it indicates
+      // old "nonisolated" state.
+
+      return false;
+    });
+  };
+
+  auto *VD = dyn_cast<ValueDecl>(decl);
+  if (!VD)
+    return false;
+
+  // The declaration is going to be printed with `nonisolated(nonsending)`
+  // attribute.
+  if (getActorIsolation(VD).isCallerIsolationInheriting())
+    return true;
+
+  // Check if any parameters that have `nonisolated(nonsending)` attribute.
+  if (auto *PL = VD->getParameterList()) {
+    if (llvm::any_of(*PL, [&](const ParamDecl *P) {
+          return hasCallerIsolatedAttr(P->getTypeRepr());
+        }))
+      return true;
+  }
+
+  // Check if result type has explicit `nonisolated(nonsending)` attribute.
+  if (hasCallerIsolatedAttr(VD->getResultTypeRepr()))
+    return true;
+
+  return false;
+}
+
 // ----------------------------------------------------------------------------
 // MARK: - FeatureSet
 // ----------------------------------------------------------------------------

test/ModuleInterface/execution_behavior_attrs.swift

@@ -6,37 +6,99 @@
 // REQUIRES: concurrency
 
 public struct Test {
-  // CHECK:  nonisolated(nonsending) public init() async
+  // CHECK: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK-NEXT: nonisolated(nonsending) public init() async
+  // CHECK-NEXT: #endif
   nonisolated(nonsending)
   public init() async {
   }
 
-  // CHECK:  @concurrent public func test() async
+  // CHECK: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK-NEXT: @concurrent public init(something: Swift.Int) async
+  // CHECK-NEXT: #endif
+  @concurrent
+  public init(something: Int) async {
+  }
+
+  // CHECK-NOT: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK: public init(noExplicit: Swift.String) async
+  // CHECK-NOT: #endif
+  public init(noExplicit: String) async {
+  }
+
+  // CHECK: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK-NEXT:  @concurrent public func test() async
+  // CHECK-NEXT: #endif
   @concurrent
   public func test() async {
   }
 
-  // CHECK:  public func other(_: nonisolated(nonsending) () async -> Swift.Void)
+  // CHECK: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK-NEXT: public func other(_: nonisolated(nonsending) () async -> Swift.Void)
+  // CHECK-NEXT: #endif
   public func other(_: nonisolated(nonsending) () async -> Void) {}
 
-  // CHECK: nonisolated(nonsending) public var testOnVar: Swift.Int {
+  // CHECK-NOT: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK: public func concurrentResult(_: () async -> Swift.Void) -> (Swift.Int) async -> Swift.Void
+  // CHECK-NOT: #endif
+  public func concurrentResult(_: () async -> Void) -> @concurrent (Int) async -> Void {}
+
+  // CHECK: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK-NEXT: public func nestedPositions1(_: Swift.Array<[Swift.String : nonisolated(nonsending) (Swift.Int) async -> Swift.Void]>)
+  // CHECK-NEXT: #endif
+  public func nestedPositions1(_: Array<[String: nonisolated(nonsending) (Int) async -> Void]>) {}
+
+  // CHECK-NOT: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK: public func nestedPositions2(_: Swift.Array<[Swift.String : (Swift.Int) async -> Swift.Void]>)
+  // CHECK-NOT: #endif
+  public func nestedPositions2(_: Array<[String: @concurrent (Int) async -> Void]>) {}
+
+  // CHECK: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK-NEXT: nonisolated(nonsending) public var testOnVar: Swift.Int {
   // CHECK-NEXT:   get async
   // CHECK-NEXT: }
+  // CHECK-NEXT: #endif
   nonisolated(nonsending)
   public var testOnVar: Int {
     get async {
       42
     }
   }
 
-  // CHECK: nonisolated(nonsending) public subscript(onSubscript _: Swift.Int) -> Swift.Bool {
+  // CHECK: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK-NEXT: @concurrent public var testOnVarConcurrent: Swift.Int {
+  // CHECK-NEXT:   get async
+  // CHECK-NEXT: }
+  // CHECK-NEXT: #endif
+  @concurrent
+  public var testOnVarConcurrent: Int {
+    get async {
+      42
+    }
+  }
+
+  // CHECK: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK-NEXT: nonisolated(nonsending) public subscript(onSubscript _: Swift.Int) -> Swift.Bool {
   // CHECK-NEXT:   get async
   // CHECK-NEXT: }
+  // CHECK-NEXT: #endif
   nonisolated(nonsending)
   public subscript(onSubscript _: Int) -> Bool {
     get async {
       false
     }
   }
+
+  // CHECK: #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes
+  // CHECK-NEXT: @concurrent public subscript(concurrentOnSubscript _: Swift.Int) -> Swift.Bool {
+  // CHECK-NEXT:   get async
+  // CHECK-NEXT: }
+  // CHECK-NEXT: #endif
+  @concurrent
+  public subscript(concurrentOnSubscript _: Int) -> Bool {
+    get async {
+      false
+    }
+  }
 }