[Concurrency] Always print @preconcurrency instead of (unsafe) in

swiftinterfaces.

Author: hborla

lib/AST/Attr.cpp

@@ -1329,8 +1329,6 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
       type.print(Printer, Options);
     else
       attr->getTypeRepr()->print(Printer, Options);
-    if (attr->isArgUnsafe() && Options.IsForSwiftInterface)
-      Printer << "(unsafe)";
     Printer.printNamePost(PrintNameContext::Attribute);
     break;
   }

lib/Sema/TypeCheckConcurrency.cpp

@@ -4652,6 +4652,8 @@ static void checkDeclWithIsolatedParameter(ValueDecl *value) {
 
 ActorIsolation ActorIsolationRequest::evaluate(
     Evaluator &evaluator, ValueDecl *value) const {
+  auto &ctx = value->getASTContext();
+
   // If this declaration has actor-isolated "self", it's isolated to that
   // actor.
   if (evaluateOrDefault(evaluator, HasIsolatedSelfRequest{value}, false)) {
@@ -4728,6 +4730,13 @@ ActorIsolation ActorIsolationRequest::evaluate(
   };
 
   auto isolationFromAttr = getIsolationFromAttributes(value);
+  if (isolationFromAttr && isolationFromAttr->preconcurrency() &&
+      !value->getAttrs().hasAttribute<PreconcurrencyAttr>()) {
+    auto preconcurrency =
+        new (ctx) PreconcurrencyAttr(/*isImplicit*/true);
+    value->getAttrs().add(preconcurrency);
+  }
+
   if (FuncDecl *fd = dyn_cast<FuncDecl>(value)) {
     // Main.main() and Main.$main are implicitly MainActor-protected.
     // Any other isolation is an error.
@@ -4807,7 +4816,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
 
       // Add an implicit attribute to capture the actor isolation that was
       // inferred, so that (e.g.) it will be printed and serialized.
-      ASTContext &ctx = value->getASTContext();
       switch (inferred) {
       case ActorIsolation::Nonisolated:
       case ActorIsolation::NonisolatedUnsafe:
@@ -4847,6 +4855,13 @@ ActorIsolation ActorIsolationRequest::evaluate(
         if (inferred == ActorIsolation::GlobalActorUnsafe)
           attr->setArgIsUnsafe(true);
         value->getAttrs().add(attr);
+
+        if (inferred.preconcurrency()) {
+          auto preconcurrency =
+              new (ctx) PreconcurrencyAttr(/*isImplicit*/true);
+          value->getAttrs().add(preconcurrency);
+        }
+
         break;
       }
 

test/ModuleInterface/concurrency.swift

@@ -25,6 +25,24 @@ public func takesMainActor(
   _ block: @MainActor @escaping () -> Void
 ) { }
 
+@MainActor(unsafe)
+public protocol UnsafeMainProtocol {
+  func requirement()
+}
+
+public struct InferredUnsafeMainActor: UnsafeMainProtocol {
+  public func requirement() {}
+}
+
+@preconcurrency @MainActor
+public protocol PreconcurrencyMainProtocol {
+  func requirement()
+}
+
+public struct InferredPreconcurrencyMainActor: PreconcurrencyMainProtocol {
+  public func requirement() {}
+}
+
 // RUN: %target-typecheck-verify-swift -enable-experimental-concurrency -I %t
 
 #else
@@ -43,6 +61,23 @@ func callFn() async {
 // CHECK: public func takesSendable(_ block: @escaping @Sendable () async throws ->
 // CHECK: public func takesMainActor(_ block: @escaping @{{_Concurrency.MainActor|MainActor}} () ->
 
+// CHECK:      @_Concurrency.MainActor @preconcurrency public protocol UnsafeMainProtocol {
+// CHECK-NEXT:   @_Concurrency.MainActor @preconcurrency func requirement()
+// CHECK-NEXT: }
+
+// CHECK:      @_Concurrency.MainActor @preconcurrency public struct InferredUnsafeMainActor :
+// CHECK-NEXT:   @_Concurrency.MainActor @preconcurrency public func requirement()
+// CHECK-NEXT: }
+
+// CHECK:      @preconcurrency @_Concurrency.MainActor public protocol PreconcurrencyMainProtocol {
+// CHECK-NEXT:   @_Concurrency.MainActor @preconcurrency func requirement()
+// CHECK-NEXT: }
+
+// CHECK:      @_Concurrency.MainActor @preconcurrency public struct InferredPreconcurrencyMainActor :
+// CHECK-NEXT:   @_Concurrency.MainActor @preconcurrency public func requirement()
+// CHECK-NEXT: }
+
+
 // RUN: %target-swift-emit-module-interface(%t/LibraryPreserveTypesAsWritten.swiftinterface) %s -enable-experimental-concurrency -DLIBRARY -module-name LibraryPreserveTypesAsWritten -module-interface-preserve-types-as-written
 // RUN: %target-swift-typecheck-module-from-interface(%t/LibraryPreserveTypesAsWritten.swiftinterface) -enable-experimental-concurrency
 // RUN: %FileCheck %s < %t/LibraryPreserveTypesAsWritten.swiftinterface