mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-25 23:46:05 +00:00
026d963cb0
Additionally this computes availability information for all platforms ahead of possibly introducing a flag to enable this behavior. rdar://123513706
120 lines
4.1 KiB
C++
120 lines
4.1 KiB
C++
//===- Availability.cpp --------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the Availability information for Decls.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/Availability.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/Attr.h"
|
|
#include "clang/AST/Decl.h"
|
|
#include "clang/Basic/TargetInfo.h"
|
|
|
|
namespace {
|
|
|
|
/// Represents the availability of a symbol across platforms.
|
|
struct AvailabilitySet {
|
|
bool UnconditionallyDeprecated = false;
|
|
bool UnconditionallyUnavailable = false;
|
|
|
|
void insert(clang::AvailabilityInfo &&Availability) {
|
|
auto *Found = getForPlatform(Availability.Domain);
|
|
if (Found)
|
|
Found->mergeWith(std::move(Availability));
|
|
else
|
|
Availabilities.emplace_back(std::move(Availability));
|
|
}
|
|
|
|
clang::AvailabilityInfo *getForPlatform(llvm::StringRef Domain) {
|
|
auto *It = llvm::find_if(Availabilities,
|
|
[Domain](const clang::AvailabilityInfo &Info) {
|
|
return Domain.compare(Info.Domain) == 0;
|
|
});
|
|
return It == Availabilities.end() ? nullptr : It;
|
|
}
|
|
|
|
private:
|
|
llvm::SmallVector<clang::AvailabilityInfo> Availabilities;
|
|
};
|
|
|
|
static void createInfoForDecl(const clang::Decl *Decl,
|
|
AvailabilitySet &Availabilities) {
|
|
// Collect availability attributes from all redeclarations.
|
|
for (const auto *RD : Decl->redecls()) {
|
|
for (const auto *A : RD->specific_attrs<clang::AvailabilityAttr>()) {
|
|
Availabilities.insert(clang::AvailabilityInfo(
|
|
A->getPlatform()->getName(), A->getIntroduced(), A->getDeprecated(),
|
|
A->getObsoleted(), A->getUnavailable(), false, false));
|
|
}
|
|
|
|
if (const auto *A = RD->getAttr<clang::UnavailableAttr>())
|
|
if (!A->isImplicit())
|
|
Availabilities.UnconditionallyUnavailable = true;
|
|
|
|
if (const auto *A = RD->getAttr<clang::DeprecatedAttr>())
|
|
if (!A->isImplicit())
|
|
Availabilities.UnconditionallyDeprecated = true;
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace clang {
|
|
|
|
void AvailabilityInfo::mergeWith(AvailabilityInfo Other) {
|
|
if (isDefault() && Other.isDefault())
|
|
return;
|
|
|
|
if (Domain.empty())
|
|
Domain = Other.Domain;
|
|
|
|
UnconditionallyUnavailable |= Other.UnconditionallyUnavailable;
|
|
UnconditionallyDeprecated |= Other.UnconditionallyDeprecated;
|
|
Unavailable |= Other.Unavailable;
|
|
|
|
Introduced = std::max(Introduced, Other.Introduced);
|
|
|
|
// Default VersionTuple is 0.0.0 so if both are non default let's pick the
|
|
// smallest version number, otherwise select the one that is non-zero if there
|
|
// is one.
|
|
if (!Deprecated.empty() && !Other.Deprecated.empty())
|
|
Deprecated = std::min(Deprecated, Other.Deprecated);
|
|
else
|
|
Deprecated = std::max(Deprecated, Other.Deprecated);
|
|
|
|
if (!Obsoleted.empty() && !Other.Obsoleted.empty())
|
|
Obsoleted = std::min(Obsoleted, Other.Obsoleted);
|
|
else
|
|
Obsoleted = std::max(Obsoleted, Other.Obsoleted);
|
|
}
|
|
|
|
AvailabilityInfo AvailabilityInfo::createFromDecl(const Decl *D) {
|
|
AvailabilitySet Availabilities;
|
|
// Walk DeclContexts upwards starting from D to find the combined availability
|
|
// of the symbol.
|
|
for (const auto *Ctx = D; Ctx;
|
|
Ctx = llvm::cast_or_null<Decl>(Ctx->getDeclContext()))
|
|
createInfoForDecl(Ctx, Availabilities);
|
|
|
|
if (auto *Avail = Availabilities.getForPlatform(
|
|
D->getASTContext().getTargetInfo().getPlatformName())) {
|
|
Avail->UnconditionallyDeprecated = Availabilities.UnconditionallyDeprecated;
|
|
Avail->UnconditionallyUnavailable =
|
|
Availabilities.UnconditionallyUnavailable;
|
|
return std::move(*Avail);
|
|
}
|
|
|
|
AvailabilityInfo Avail;
|
|
Avail.UnconditionallyDeprecated = Availabilities.UnconditionallyDeprecated;
|
|
Avail.UnconditionallyUnavailable = Availabilities.UnconditionallyUnavailable;
|
|
return Avail;
|
|
}
|
|
|
|
} // namespace clang
|