[clang][ExtractAPI] Handle platform specific unavailability correctly

[Arsenic]

Summary

This Patch gives ExtractAPI the ability to emit correct availability
information for symbols marked as unavailable on a specific platform
( PR#60954 )

[Arsenic]

duplicate of https://reviews.llvm.org/D144940

clang/include/clang/ExtractAPI/AvailabilityInfo.h

 
 /// Stores availability attributes of a symbol in a given domain.
 struct AvailabilityInfo {
   /// The domain for which this availability info item applies
   std::string Domain;
   VersionTuple Introduced;
   VersionTuple Deprecated;
   VersionTuple Obsoleted;
+  bool Unavailable;
 
   AvailabilityInfo() = default;
 
   AvailabilityInfo(StringRef Domain, VersionTuple I, VersionTuple D,
-                   VersionTuple O)
-      : Domain(Domain), Introduced(I), Deprecated(D), Obsoleted(O) {}
+                   VersionTuple O, bool U)
+      : Domain(Domain), Introduced(I), Deprecated(D), Obsoleted(O),
+        Unavailable(U) {}
 };
 
 class AvailabilitySet {
 private:
   using AvailabilityList = llvm::SmallVector<AvailabilityInfo, 4>;
   AvailabilityList Availabilities;
 
   bool UnconditionallyDeprecated = false;

clang/lib/ExtractAPI/AvailabilityInfo.cpp

for (const auto *Attr : RD->specific_attrs<AvailabilityAttr>()) {
         if (Availability->Deprecated > Attr->getDeprecated())
           Availability->Deprecated = Attr->getDeprecated();
 
         // Get the lowest obsoleted version for all redeclarations.
         if (Availability->Obsoleted > Attr->getObsoleted())
           Availability->Obsoleted = Attr->getObsoleted();
       } else {
         Availabilities.emplace_back(Domain, Attr->getIntroduced(),
-                                    Attr->getDeprecated(),
-                                    Attr->getObsoleted());
+                                    Attr->getDeprecated(), Attr->getObsoleted(),
+                                    Attr->getUnavailable());
       }
     }
   }
 }

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

if (Availabilities.isUnconditionallyDeprecated()) {
     AvailabilityArray.emplace_back(std::move(UnconditionallyDeprecated));
   }
 
   // Note unconditionally unavailable records are skipped.
 
   for (const auto &AvailInfo : Availabilities) {
     Object Availability;
     Availability["domain"] = AvailInfo.Domain;
+    if (AvailInfo.Unavailable)
+      Availability["isUnconditionallyUnavailable"] = true;
+    else {
       serializeObject(Availability, "introducedVersion",
                       serializeSemanticVersion(AvailInfo.Introduced));
       serializeObject(Availability, "deprecatedVersion",
                       serializeSemanticVersion(AvailInfo.Deprecated));
       serializeObject(Availability, "obsoletedVersion",
                       serializeSemanticVersion(AvailInfo.Obsoleted));
+    }
     AvailabilityArray.emplace_back(std::move(Availability));
   }
 
   return AvailabilityArray;
 }
 
 /// Get the language name string for interface language references.
 StringRef getLanguageName(Language Lang) {

clang/test/ExtractAPI/availability.c

 
 void d(void) __attribute__((availability(macos, introduced=11.0, deprecated=12.0, obsoleted=20.0))) __attribute__((availability(ios, introduced=13.0)));
 
 void e(void) __attribute__((deprecated)) __attribute__((availability(macos, introduced=11.0)));
 
 void f(void) __attribute__((unavailable)) __attribute__((availability(macos, introduced=11.0)));
 
 void d(void) __attribute__((availability(tvos, introduced=15.0)));
+
+void e(void) __attribute__((availability(tvos, unavailable)));
+
 ///expected-no-diagnostics
 
 //--- reference.output.json.in
 {
   "metadata": {
     "formatVersion": {
       "major": 0,
       "minor": 5,
"symbols": [
         },
         {
           "domain": "macos",
           "introducedVersion": {
             "major": 11,
             "minor": 0,
             "patch": 0
           }
+        },
+        {
+          "domain": "tvos",
+          "isUnconditionallyUnavailable": true
         }
       ],
       "declarationFragments": [
         {
           "kind": "typeIdentifier",
           "preciseIdentifier": "c:v",
           "spelling": "void"
         },