PrintAsClang: Add support for availability attrs with custom domains.

tshortli · tshortli · commit 58bf087a0e51 · 2025-07-23T21:53:05.000-07:00
Resolves rdar://154510571.
diff --git a/include/swift/PrintAsClang/ClangMacros.def b/include/swift/PrintAsClang/ClangMacros.def
@@ -220,6 +220,7 @@ CLANG_MACRO("SWIFT_UNAVAILABLE", , "__attribute__((unavailable))")
 CLANG_MACRO("SWIFT_UNAVAILABLE_MSG", "(msg)", "__attribute__((unavailable(msg)))")
 
 CLANG_MACRO("SWIFT_AVAILABILITY", "(plat, ...)", "__attribute__((availability(plat, __VA_ARGS__)))")
+CLANG_MACRO("SWIFT_AVAILABILITY_DOMAIN", "(dom, ...)", "__attribute__((availability(domain: dom, __VA_ARGS__)))")
 
 CLANG_MACRO("SWIFT_WEAK_IMPORT", , "__attribute__((weak_import))")
 
diff --git a/lib/PrintAsClang/DeclAndTypePrinter.cpp b/lib/PrintAsClang/DeclAndTypePrinter.cpp
@@ -1702,9 +1702,24 @@ class DeclAndTypePrinter::Implementation
     };
 
     for (auto AvAttr : D->getSemanticAvailableAttrs()) {
-      if (AvAttr.getPlatform() == PlatformKind::none) {
-        if (AvAttr.isUnconditionallyUnavailable() &&
-            !AvAttr.getDomain().isSwiftLanguage()) {
+      auto domain = AvAttr.getDomain();
+      if (auto domainDecl = domain.getDecl()) {
+        // If the domain is defined in a Clang module then the attr can be
+        // printed.
+        if (domainDecl->hasClangNode()) {
+          // Versioned custom domains aren't supported yet.
+          ASSERT(!domain.isVersioned());
+
+          maybePrintLeadingSpace();
+          os << "SWIFT_AVAILABILITY_DOMAIN("
+             << domain.getNameForAttributePrinting() << ","
+             << (AvAttr.isUnconditionallyUnavailable() ? "1" : "0") << ")";
+        }
+        continue;
+      }
+
+      if (domain.isUniversal()) {
+        if (AvAttr.isUnconditionallyUnavailable()) {
           // Availability for *
           if (!AvAttr.getRename().empty() && isa<ValueDecl>(D)) {
             // rename
@@ -1749,6 +1764,9 @@ class DeclAndTypePrinter::Implementation
       }
 
       // Availability for a specific platform
+      if (!domain.isPlatform())
+        continue;
+
       if (!AvAttr.getIntroduced().has_value() &&
           !AvAttr.getDeprecated().has_value() &&
           !AvAttr.getObsoleted().has_value() &&
diff --git a/lib/PrintAsClang/ModuleContentsWriter.cpp b/lib/PrintAsClang/ModuleContentsWriter.cpp
@@ -684,6 +684,8 @@ class ModuleWriter {
         continue;
       }
 
+      addImportsForReferencedAvailabilityDomains(member);
+
       bool needsToBeIndividuallyDelayed = false;
       ReferencedTypeFinder::walk(VD->getInterfaceType(),
                                  [&](ReferencedTypeFinder &finder,
@@ -745,6 +747,15 @@ class ModuleWriter {
     return !hadAnyDelayedMembers;
   }
 
+  void addImportsForReferencedAvailabilityDomains(const Decl *D) {
+    for (auto attr : D->getSemanticAvailableAttrs()) {
+      if (auto *domainDecl = attr.getDomain().getDecl()) {
+        if (domainDecl->hasClangNode())
+          addImport(domainDecl);
+      }
+    }
+  }
+
   bool writeClass(const ClassDecl *CD) {
     if (addImport(CD))
       return true;
@@ -777,6 +788,7 @@ class ModuleWriter {
     if (outputLangMode == OutputLanguageMode::Cxx &&
         (inserted || !it->second.second))
       ClangValueTypePrinter::forwardDeclType(os, CD, printer);
+    addImportsForReferencedAvailabilityDomains(CD);
     it->second = {EmissionState::Defined, true};
     printer.print(CD);
     return true;
@@ -795,6 +807,7 @@ class ModuleWriter {
                                      TD);
           forwardDeclareType(TD);
         });
+    addImportsForReferencedAvailabilityDomains(FD);
 
     printer.print(FD);
     return true;
@@ -811,6 +824,7 @@ class ModuleWriter {
       }
       forwardDeclareCxxValueTypeIfNeeded(SD);
     }
+    addImportsForReferencedAvailabilityDomains(SD);
     printer.print(SD);
     return true;
   }
@@ -837,6 +851,8 @@ class ModuleWriter {
     if (!forwardDeclareMemberTypes(PD->getAllMembers(), PD))
       return false;
 
+    addImportsForReferencedAvailabilityDomains(PD);
+
     seenTypes[PD] = { EmissionState::Defined, true };
     printer.print(PD);
     return true;
@@ -863,6 +879,8 @@ class ModuleWriter {
     if (!forwardDeclareMemberTypes(ED->getAllMembers(), ED))
       return false;
 
+    addImportsForReferencedAvailabilityDomains(ED);
+
     printer.print(ED);
     return true;
   }
@@ -882,7 +900,9 @@ class ModuleWriter {
 
     if (seenTypes[ED].first == EmissionState::Defined)
       return true;
-    
+
+    addImportsForReferencedAvailabilityDomains(ED);
+
     seenTypes[ED] = {EmissionState::Defined, true};
     printer.print(ED);
 
diff --git a/test/ClangImporter/Inputs/availability_domains_bridging_header.h b/test/ClangImporter/Inputs/availability_domains_bridging_header.h
@@ -1,8 +1,8 @@
 #include <feature-availability.h>
 
-static struct __AvailabilityDomain __BayBridge
+static struct __AvailabilityDomain bay_bridge
     __attribute__((availability_domain(BayBridge))) = {
         __AVAILABILITY_DOMAIN_ENABLED, 0};
-static struct __AvailabilityDomain __GoldenGateBridge
+static struct __AvailabilityDomain golden_gate_bridge
     __attribute__((availability_domain(GoldenGateBridge))) = {
         __AVAILABILITY_DOMAIN_DISABLED, 0};
diff --git a/test/Inputs/custom-modules/availability-domains/Oceans.h b/test/Inputs/custom-modules/availability-domains/Oceans.h
@@ -4,10 +4,10 @@
 int arctic_pred(void);
 int pacific_pred(void);
 
-static struct __AvailabilityDomain __Arctic
+static struct __AvailabilityDomain arctic_domain
     __attribute__((availability_domain(Arctic))) = {
         __AVAILABILITY_DOMAIN_DYNAMIC, arctic_pred};
-static struct __AvailabilityDomain __Pacific
+static struct __AvailabilityDomain pacific_domain
     __attribute__((availability_domain(Pacific))) = {
         __AVAILABILITY_DOMAIN_DYNAMIC, pacific_pred};
 
diff --git a/test/Inputs/custom-modules/availability-domains/Rivers.h b/test/Inputs/custom-modules/availability-domains/Rivers.h
@@ -1,6 +1,6 @@
 #include <feature-availability.h>
 
-static struct __AvailabilityDomain __Colorado __attribute__((
+static struct __AvailabilityDomain colorado_domain __attribute__((
     availability_domain(Colorado))) = {__AVAILABILITY_DOMAIN_DISABLED, 0};
 
 #define AVAIL 0
diff --git a/test/Inputs/custom-modules/availability-domains/Seas.h b/test/Inputs/custom-modules/availability-domains/Seas.h
@@ -1,8 +1,8 @@
 #include <feature-availability.h>
 
-static struct __AvailabilityDomain __Baltic __attribute__((
+static struct __AvailabilityDomain baltic_domain __attribute__((
     availability_domain(Baltic))) = {__AVAILABILITY_DOMAIN_ENABLED, 0};
-static struct __AvailabilityDomain __Mediterranean __attribute__((
+static struct __AvailabilityDomain _mediterranean __attribute__((
     availability_domain(Mediterranean))) = {__AVAILABILITY_DOMAIN_ENABLED, 0};
 
 #define AVAIL 0
diff --git a/test/PrintAsObjC/availability_custom_domains.swift b/test/PrintAsObjC/availability_custom_domains.swift
@@ -0,0 +1,232 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck \
+// RUN:   -verify -disable-objc-attr-requires-foundation-module \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -import-objc-header %S/../Inputs/empty.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -emit-objc-header-path %t/func.h -DFUNC
+
+// RUN: %FileCheck %s --check-prefixes=CHECK-FUNC --input-file %t/func.h
+// RUN: %check-in-clang -I %S/../Inputs/custom-modules/availability-domains %t/func.h
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck \
+// RUN:   -verify -disable-objc-attr-requires-foundation-module \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -import-objc-header %S/../Inputs/empty.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -emit-objc-header-path %t/class.h -DCLASS
+
+// RUN: %FileCheck %s --check-prefixes=CHECK-CLASS --input-file %t/class.h
+// RUN: %check-in-clang -I %S/../Inputs/custom-modules/availability-domains %t/class.h
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck \
+// RUN:   -verify -disable-objc-attr-requires-foundation-module \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -import-objc-header %S/../Inputs/empty.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -emit-objc-header-path %t/class_member.h -DCLASS_MEMBER
+
+// RUN: %FileCheck %s --check-prefixes=CHECK-CLASS-MEMBER --input-file %t/class_member.h
+// RUN: %check-in-clang -I %S/../Inputs/custom-modules/availability-domains %t/class_member.h
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck \
+// RUN:   -verify -disable-objc-attr-requires-foundation-module \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -import-objc-header %S/../Inputs/empty.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -emit-objc-header-path %t/protocol.h -DPROTOCOL
+
+// RUN: %FileCheck %s --check-prefixes=CHECK-PROTOCOL --input-file %t/protocol.h
+// RUN: %check-in-clang -I %S/../Inputs/custom-modules/availability-domains %t/protocol.h
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck \
+// RUN:   -verify -disable-objc-attr-requires-foundation-module \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -import-objc-header %S/../Inputs/empty.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -emit-objc-header-path %t/protocol_member.h -DPROTOCOL_MEMBER
+
+// RUN: %FileCheck %s --check-prefixes=CHECK-PROTOCOL-MEMBER --input-file %t/protocol_member.h
+// RUN: %check-in-clang -I %S/../Inputs/custom-modules/availability-domains %t/protocol_member.h
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck \
+// RUN:   -verify -disable-objc-attr-requires-foundation-module \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -import-objc-header %S/../Inputs/empty.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -emit-objc-header-path %t/extension.h -DEXTENSION
+
+// RUN: %FileCheck %s --check-prefixes=CHECK-EXTENSION --input-file %t/extension.h
+// RUN: %check-in-clang -I %S/../Inputs/custom-modules/availability-domains %t/extension.h
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck \
+// RUN:   -verify -disable-objc-attr-requires-foundation-module \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -import-objc-header %S/../Inputs/empty.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -emit-objc-header-path %t/extension_member.h -DEXTENSION_MEMBER
+
+// RUN: %FileCheck %s --check-prefixes=CHECK-EXTENSION-MEMBER --input-file %t/extension_member.h
+// RUN: %check-in-clang -I %S/../Inputs/custom-modules/availability-domains %t/extension_member.h
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck \
+// RUN:   -verify -disable-objc-attr-requires-foundation-module \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -import-objc-header %S/../Inputs/empty.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -emit-objc-header-path %t/enum.h -DENUM
+
+// RUN: %FileCheck %s --check-prefixes=CHECK-ENUM --input-file %t/enum.h
+// RUN: %check-in-clang -I %S/../Inputs/custom-modules/availability-domains %t/enum.h
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck \
+// RUN:   -verify -disable-objc-attr-requires-foundation-module \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -import-objc-header %S/../Inputs/empty.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -emit-objc-header-path %t/enum_member.h -DENUM_MEMBER
+
+// RUN: %FileCheck %s --check-prefixes=CHECK-ENUM-MEMBER --input-file %t/enum_member.h
+// RUN: %check-in-clang -I %S/../Inputs/custom-modules/availability-domains %t/enum_member.h
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) %s -typecheck \
+// RUN:   -verify -disable-objc-attr-requires-foundation-module \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   -import-objc-header %S/../Inputs/empty.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -emit-objc-header-path %t/private.h -DPRIVATE
+
+// RUN: %FileCheck %s --check-prefix=CHECK-PRIVATE --input-file %t/private.h
+// RUN: %check-in-clang -I %S/../Inputs/custom-modules/availability-domains %t/private.h
+
+// REQUIRES: swift_feature_CustomAvailability
+// REQUIRES: objc_interop
+
+import Oceans
+
+#if FUNC
+
+// CHECK-FUNC: SWIFT_EXTERN void arctic_func(void) SWIFT_NOEXCEPT SWIFT_AVAILABILITY_DOMAIN(Arctic,0);
+@available(Arctic)
+@_cdecl("arctic_func") func arcticFunc() { }
+
+#elseif CLASS
+
+// CHECK-CLASS: SWIFT_AVAILABILITY_DOMAIN(Arctic,0)
+// CHECK-CLASS-LABEL: @interface ArcticClass{{$}}
+@available(Arctic)
+@objc class ArcticClass {
+  // CHECK-CLASS-NEXT: - (void)alwaysAvailable;
+  @objc func alwaysAvailable() { }
+}
+// CHECK-CLASS-LABEL: @end
+
+#elseif CLASS_MEMBER
+
+// CHECK-CLASS-MEMBER-LABEL: @interface AvailableClass{{$}}
+@objc class AvailableClass {
+  // CHECK-CLASS-MEMBER-NEXT: - (void)availableInArctic SWIFT_AVAILABILITY_DOMAIN(Arctic,0);
+  @available(Arctic)
+  @objc func availableInArctic() { }
+
+  // CHECK-CLASS-MEMBER-NEXT: @property (nonatomic) NSInteger unavailableInArctic SWIFT_AVAILABILITY_DOMAIN(Arctic,1);
+  @available(Arctic, unavailable)
+  @objc var unavailableInArctic: Int {
+    get { 0 }
+    set { }
+  }
+}
+// CHECK-CLASS-MEMBER-LABEL: @end
+
+#elseif PROTOCOL
+
+// CHECK-PROTOCOL: SWIFT_AVAILABILITY_DOMAIN(Arctic,0)
+// CHECK-PROTOCOL-LABEL: @protocol ArcticProtocol{{$}}
+@available(Arctic)
+@objc protocol ArcticProtocol {
+  // CHECK-PROTOCOL-NEXT: - (void)requirement;
+  func requirement()
+}
+// CHECK-PROTOCOL-LABEL: @end
+
+#elseif PROTOCOL_MEMBER
+
+// CHECK-PROTOCOL-MEMBER-LABEL: @protocol AvailableProtocol{{$}}
+@objc protocol AvailableProtocol {
+  // CHECK-PROTOCOL-MEMBER-NEXT: - (void)availableInArctic SWIFT_AVAILABILITY_DOMAIN(Arctic,0);
+  @available(Arctic)
+  func availableInArctic()
+
+  func requirement()
+}
+// CHECK-PROTOCOL-MEMBER-LABEL: @end
+
+#elseif EXTENSION
+
+// CHECK-EXTENSION-LABEL: @interface AvailableClass{{$}}
+@objc class AvailableClass {
+}
+// CHECK-EXTENSION-LABEL: @end
+
+// CHECK-EXTENSION-LABEL: SWIFT_AVAILABILITY_DOMAIN(Arctic,0)
+// CHECK-EXTENSION-NEXT: @interface AvailableClass (SWIFT_EXTENSION(availability_custom_domains))
+@available(Arctic)
+extension AvailableClass {
+  // CHECK-EXTENSION-NEXT: - (void)alwaysAvailable;
+  @objc func alwaysAvailable() { }
+}
+// CHECK-EXTENSION-LABEL: @end
+
+#elseif EXTENSION_MEMBER
+
+// CHECK-EXTENSION-MEMBER-LABEL: @interface AvailableClass{{$}}
+@objc class AvailableClass {
+}
+// CHECK-EXTENSION-MEMBER-LABEL: @end
+
+// CHECK-EXTENSION-MEMBER-LABEL: @interface AvailableClass (SWIFT_EXTENSION(availability_custom_domains))
+extension AvailableClass {
+  // CHECK-EXTENSION-MEMBER-NEXT: - (void)availableInArctic SWIFT_AVAILABILITY_DOMAIN(Arctic,0);
+  @available(Arctic)
+  @objc func availableInArctic() { }
+}
+// CHECK-EXTENSION-MEMBER-LABEL: @end
+
+#elseif ENUM
+
+// FIXME: [availability] Availability attribute is missing
+// CHECK-ENUM-LABEL: typedef SWIFT_ENUM(NSInteger, ArcticEnum, closed)
+@available(Arctic)
+@objc enum ArcticEnum: Int {
+  // CHECK-ENUM-NEXT: ArcticEnumAvailable = 0,
+  case available
+}
+// CHECK-ENUM-NEXT: };
+
+#elseif ENUM_MEMBER
+
+// FIXME: [availability] Availability attribute is missing
+// CHECK-ENUM-MEMBER-LABEL: typedef SWIFT_ENUM(NSInteger, AvailableEnum, closed)
+@objc enum AvailableEnum: Int {
+  // CHECK-ENUM-MEMBER-NEXT: AvailableEnumAvailableInArctic = 0,
+  @available(Arctic)
+  case availableInArctic
+}
+// CHECK-ENUM-MEMBER-NEXT: };
+
+#elseif PRIVATE
+
+// CHECK-PRIVATE-NOT: @import Oceans;
+// CHECK-PRIVATE-NOT: @interface PrivateClass
+@available(Arctic)
+@objc private class PrivateClass { }
+
+// CHECK-PRIVATE-LABEL: @interface ClassWithPrivateMember{{$}}
+@objc class ClassWithPrivateMember {
+  // CHECK-PRIVATE-NOT: - (void)member;
+  @available(Arctic)
+  @objc private func member() { }
+}
+
+#endif
