[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]

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

550

These changes seems to have added by clang-format.
Is there a way to not let clang format edit the code that I haven't touched ?

[dang]

Nice! glad to see this getting fixed. You should add a lit test to ensure we don't regress this behavior in the future.

clang/include/clang/ExtractAPI/AvailabilityInfo.h

48

I don't think this change here is necessary.

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

550

Yes you can use git-clang-format, instructions here for setup: https://offlinemark.com/2021/04/02/surgical-formatting-with-git-clang-format/

[Arsenic]

In D144940#4158020, @dang wrote:

Nice! glad to see this getting fixed. You should add a lit test to ensure we don't regress this behavior in the future.

I see a test checking for availability attribute already exists ( clang/test/ExtractAPI/availability.c ) would it be better if I update it with another function having a platform specific unavailability attribute or should I create a new test file ?

[dang]

In D144940#4158143, @Arsenic wrote:

In D144940#4158020, @dang wrote:

Nice! glad to see this getting fixed. You should add a lit test to ensure we don't regress this behavior in the future.

I see a test checking for availability attribute already exists ( clang/test/ExtractAPI/availability.c ) would it be better if I update it with another function having a platform specific unavailability attribute or should I create a new test file ?

Yes I think updating that test with another API that has a platform specific unavailability attribute is the best way to do this.

[Arsenic]

Add test to check platform specific unavailability

The update also remove the useless changes that were introduced by
using clang format on the entire file instead of current commit.

[dang]

LGTM, It's worth noting that if the user specifies that an API is unavailable in a later redeclaration, this will be ignored. For example if I add a line to the test void e(void) __attribute__((availability(macos, unavailable))); it will be ignored. Up to you whether you want to fix it now or at a later date.

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;
   bool UnconditionallyUnavailable = false;
 
 public:
   AvailabilitySet(const Decl *Decl);
   AvailabilitySet() = default;

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) {
Array generateParentContexts(const RecordTy &Record, const APISet &API,
                              Language Lang) {
   Array ParentContexts;
   generatePathComponents(Record, API,
                          [Lang, &ParentContexts](const PathComponent &PC) {
                            ParentContexts.push_back(
                                serializeParentContext(PC, Lang));
                          });
 
   // The last component would be the record itself so let's remove it.
   if (!ParentContexts.empty())
     ParentContexts.pop_back();
 
   return ParentContexts;
 }
 
 } // namespace
 

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"
         },