Merge pull request #36655 from kavon/double-double-mainactor-style

Author: swift-ci

include/swift/AST/DiagnosticsClangImporter.def

@@ -83,5 +83,9 @@ WARNING(implicit_bridging_header_imported_from_module,none,
         "is deprecated and will be removed in a later version of Swift",
         (StringRef, Identifier))
 
+WARNING(import_multiple_mainactor_attr,none,
+      "this attribute for global actor '%0' is invalid; the declaration already has attribute for global actor '%1'",
+      (StringRef, StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

lib/ClangImporter/ImportDecl.cpp

@@ -8353,6 +8353,7 @@ void ClangImporter::Implementation::importAttributes(
   // Scan through Clang attributes and map them onto Swift
   // equivalents.
   PatternBindingInitializer *initContext = nullptr;
+  Optional<const clang::SwiftAttrAttr *> SeenMainActorAttr;
   bool AnyUnavailable = MappedDecl->getAttrs().isUnavailable(C);
   for (clang::NamedDecl::attr_iterator AI = ClangDecl->attr_begin(),
        AE = ClangDecl->attr_end(); AI != AE; ++AI) {
@@ -8496,15 +8497,32 @@ void ClangImporter::Implementation::importAttributes(
     // __attribute__((swift_attr("attribute")))
     //
     if (auto swiftAttr = dyn_cast<clang::SwiftAttrAttr>(*AI)) {
-      // FIXME: Hard-core @MainActor and @UIActor, because we don't have a
+      // FIXME: Hard-code @MainActor and @UIActor, because we don't have a
       // point at which to do name lookup for imported entities.
       if (auto isMainActor = isMainActorAttr(SwiftContext, swiftAttr)) {
         bool isUnsafe = *isMainActor;
+
+        if (SeenMainActorAttr) {
+          // Cannot add main actor annotation twice. We'll keep the first
+          // one and raise a warning about the duplicate.
+          auto &clangSrcMgr = getClangASTContext().getSourceManager();
+          ClangSourceBufferImporter &bufferImporter =
+              getBufferImporterForDiagnostics();
+          SourceLoc attrLoc = bufferImporter.resolveSourceLocation(
+              clangSrcMgr, swiftAttr->getLocation());
+
+          diagnose(attrLoc, diag::import_multiple_mainactor_attr,
+                   swiftAttr->getAttribute(),
+                   SeenMainActorAttr.getValue()->getAttribute());
+          continue;
+        }
+
         if (Type mainActorType = SwiftContext.getMainActorType()) {
           auto typeExpr = TypeExpr::createImplicit(mainActorType, SwiftContext);
           auto attr = CustomAttr::create(SwiftContext, SourceLoc(), typeExpr);
           attr->setArgIsUnsafe(isUnsafe);
           MappedDecl->getAttrs().add(attr);
+          SeenMainActorAttr = swiftAttr;
         }
 
         continue;

test/ClangImporter/Inputs/DoubleMainActor.h

@@ -0,0 +1,17 @@
+@import Foundation;
+
+#pragma clang assume_nonnull begin
+
+#define SWIFT_MAIN_ACTOR __attribute__((swift_attr("@MainActor")))
+#define SWIFT_UI_ACTOR __attribute__((swift_attr("@UIActor")))
+
+// NOTE: If you ever end up removing support for the "@UIActor" alias,
+// just change both to be @MainActor and it won't change the purpose of
+// this test.
+
+SWIFT_UI_ACTOR SWIFT_MAIN_ACTOR @protocol DoubleMainActor
+@required
+- (NSString *)createSeaShanty:(NSInteger)number;
+@end
+
+#pragma clang assume_nonnull end

test/ClangImporter/duplicate_mainactor.swift

@@ -0,0 +1,10 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -enable-experimental-concurrency -import-objc-header %S/Inputs/DoubleMainActor.h -emit-module -module-name use %s 2> %t/stderr.txt
+// RUN: %FileCheck -input-file %t/stderr.txt %s
+
+// REQUIRES: concurrency
+// REQUIRES: objc_interop
+
+// CHECK: DoubleMainActor.h:{{[0-9]+}}:{{[0-9]+}}: warning: this attribute for global actor '@MainActor' is invalid; the declaration already has attribute for global actor '@UIActor'
+
+protocol P : DoubleMainActor {}

test/IDE/print_clang_objc_async.swift

@@ -92,3 +92,5 @@ import _Concurrency
 // CHECK: {{^}}var MAGIC_NUMBER: Int32 { get }
 
 // CHECK: func doSomethingConcurrently(_ block: @Sendable () -> Void)
+
+// CHECK: @MainActor protocol TripleMainActor {

test/Inputs/clang-importer-sdk/usr/include/ObjCConcurrency.h

@@ -157,4 +157,8 @@ void doSomethingConcurrently(__attribute__((noescape)) __attribute__((swift_attr
 
 void doSomethingConcurrentlyButUnsafe(__attribute__((noescape)) __attribute__((swift_attr("@_unsafeSendable"))) void (^block)(void));
 
+
+MAIN_ACTOR MAIN_ACTOR __attribute__((__swift_attr__("@MainActor(unsafe)"))) @protocol TripleMainActor
+@end
+
 #pragma clang assume_nonnull end