Merge pull request #83280 from tshortli/print-as-clang-custom-availability-domains

tshortli · web-flow · commit 5d91d02bfff8 · 2025-07-24T06:17:05.000-07:00
PrintAsClang: Add support for custom availability domains
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,70 @@
 #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};
+
+#define AVAIL 0
+#define UNAVAIL 1
+
+
+#if __OBJC__
+@import Foundation;
+
+__attribute__((availability(domain:BayBridge, AVAIL)))
+@interface BayBridgeAvailable : NSObject
+- (instancetype)init;
+@end
+
+__attribute__((availability(domain:BayBridge, UNAVAIL)))
+@interface BayBridgeUnavailable : NSObject
+- (instancetype)init;
+@end
+
+@interface ImplementMe : NSObject
+- (instancetype)init;
+- (void)availableInBayBridge __attribute__((availability(domain:BayBridge, AVAIL)));
+- (void)unavailableInBayBridge __attribute__((availability(domain:BayBridge, UNAVAIL)));
+
+- (void)availableInGoldenGateBridge __attribute__((availability(domain:GoldenGateBridge, AVAIL)));
+- (void)unavailableInGoldenGateBridge __attribute__((availability(domain:GoldenGateBridge, UNAVAIL)));
+
+@end
+
+__attribute__((availability(domain:BayBridge, AVAIL)))
+@interface ImplementMeBayBridgeAvailable : NSObject
+- (instancetype)init;
+@end
+
+__attribute__((availability(domain:BayBridge, UNAVAIL)))
+@interface ImplementMeBayBridgeUnavailable : NSObject
+- (instancetype)init;
+@end
+
+__attribute__((availability(domain:GoldenGateBridge, AVAIL)))
+@interface ImplementMeGoldenGateBridgeAvailable : NSObject
+- (instancetype)init;
+@end
+
+__attribute__((availability(domain:GoldenGateBridge, AVAIL)))
+@interface ImplementMeGoldenGateBridgeAvailable2 : NSObject
+- (instancetype)init;
+@end
+
+__attribute__((availability(domain:GoldenGateBridge, AVAIL)))
+@interface ImplementMeGoldenGateBridgeAvailable3 : NSObject
+- (instancetype)init;
+@end
+
+__attribute__((availability(domain:GoldenGateBridge, UNAVAIL)))
+@interface ImplementMeGoldenGateBridgeUnavailable : NSObject
+- (instancetype)init;
+@end
+
+#endif // __OBJC__
+
+#undef UNAVAIL
+#undef AVAIL
diff --git a/test/ClangImporter/availability_custom_domains_objc.swift b/test/ClangImporter/availability_custom_domains_objc.swift
@@ -0,0 +1,80 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -verify \
+// RUN:   -import-objc-header %S/Inputs/availability_domains_bridging_header.h \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   %s %S/Inputs/availability_custom_domains_other.swift
+
+// Re-test with the bridging header precompiled into a .pch.
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-pch \
+// RUN:   -o %t/bridging-header.pch %S/Inputs/availability_domains_bridging_header.h
+
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -typecheck -verify \
+// RUN:   -import-objc-header %t/bridging-header.pch \
+// RUN:   -I %S/../Inputs/custom-modules/availability-domains \
+// RUN:   -enable-experimental-feature CustomAvailability \
+// RUN:   %s %S/Inputs/availability_custom_domains_other.swift
+
+// REQUIRES: swift_feature_CustomAvailability
+// REQUIRES: objc_interop
+
+import Oceans // re-exports Rivers
+
+func testObjCClasses( // expected-note {{add '@available' attribute to enclosing global function}}
+  _ bayBridgeAvailable: BayBridgeAvailable, // expected-error {{'BayBridgeAvailable' is only available in BayBridge}}
+  _ bayBridgeUnavailable: BayBridgeUnavailable, // expected-error {{'BayBridgeUnavailable' is unavailable}}
+) { }
+
+@objc @implementation
+extension ImplementMe {
+  // FIXME: [availability] @available(BayBridge) should be required
+  func availableInBayBridge() { }
+
+  // FIXME: [availability] Should match and suggest @available(BayBridge, unavailable)
+  func unavailableInBayBridge() { } // expected-error {{instance method 'unavailableInBayBridge()' does not match any instance method declared in the headers for 'ImplementMe'}}
+  // expected-note@-1 {{add 'private' or 'fileprivate'}}
+  // expected-note@-2 {{add 'final' to define a Swift-only instance method}}
+
+  @available(GoldenGateBridge)
+  func availableInGoldenGateBridge() { }
+
+  // FIXME: [availability] This should be accepted
+  @available(GoldenGateBridge, unavailable)
+  func unavailableInGoldenGateBridge() { } // expected-error {{instance method 'unavailableInGoldenGateBridge()' does not match any instance method declared in the headers for 'ImplementMe'}}
+  // expected-note@-1 {{add 'private' or 'fileprivate'}}
+  // expected-note@-2 {{add 'final' to define a Swift-only instance method}}
+}
+
+@objc @implementation
+extension ImplementMeBayBridgeAvailable { // expected-error {{'ImplementMeBayBridgeAvailable' is only available in BayBridge}}
+  // expected-note@-1 {{add '@available' attribute to enclosing extension}}
+}
+
+@objc @implementation
+extension ImplementMeBayBridgeUnavailable { // expected-error {{'ImplementMeBayBridgeUnavailable' is unavailable}}
+}
+
+@available(GoldenGateBridge)
+@objc @implementation
+extension ImplementMeGoldenGateBridgeAvailable {
+}
+
+@available(BayBridge)
+@objc @implementation
+extension ImplementMeGoldenGateBridgeAvailable2 { // expected-error {{'ImplementMeGoldenGateBridgeAvailable2' is only available in GoldenGateBridge}}
+  // expected-note@-1 {{add '@available' attribute to enclosing extension}}
+}
+
+// FIXME: [availability] This implementation should be rejected because its less
+// available than the original class declaration.
+@available(BayBridge)
+@available(GoldenGateBridge)
+@objc @implementation
+extension ImplementMeGoldenGateBridgeAvailable3 {
+}
+
+@available(GoldenGateBridge, unavailable)
+@objc @implementation
+extension ImplementMeGoldenGateBridgeUnavailable {
+}
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
