1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
//===- 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
|
