[NFC] Rename clang::AttributeList to clang::ParsedAttr
Since The type no longer contains the 'next' item anymore, it isn't a list,
so rename it to ParsedAttr to be more accurate.
llvm-svn: 337005
diff --git a/clang/lib/Sema/CMakeLists.txt b/clang/lib/Sema/CMakeLists.txt
index 7d9ae62..bad42a2 100644
--- a/clang/lib/Sema/CMakeLists.txt
+++ b/clang/lib/Sema/CMakeLists.txt
@@ -9,13 +9,13 @@
add_clang_library(clangSema
AnalysisBasedWarnings.cpp
- AttributeList.cpp
CodeCompleteConsumer.cpp
DeclSpec.cpp
DelayedDiagnostic.cpp
IdentifierResolver.cpp
JumpDiagnostics.cpp
MultiplexExternalSemaSource.cpp
+ ParsedAttr.cpp
Scope.cpp
ScopeInfo.cpp
Sema.cpp
diff --git a/clang/lib/Sema/DeclSpec.cpp b/clang/lib/Sema/DeclSpec.cpp
index 01c9bad..ccca5d3 100644
--- a/clang/lib/Sema/DeclSpec.cpp
+++ b/clang/lib/Sema/DeclSpec.cpp
@@ -994,7 +994,7 @@
writtenBS.Width = getTypeSpecWidth();
writtenBS.Type = getTypeSpecType();
// Search the list of attributes for the presence of a mode attribute.
- writtenBS.ModeAttr = getAttributes().hasAttribute(AttributeList::AT_Mode);
+ writtenBS.ModeAttr = getAttributes().hasAttribute(ParsedAttr::AT_Mode);
}
/// Finish - This does final analysis of the declspec, rejecting things like
diff --git a/clang/lib/Sema/AttributeList.cpp b/clang/lib/Sema/ParsedAttr.cpp
similarity index 68%
rename from clang/lib/Sema/AttributeList.cpp
rename to clang/lib/Sema/ParsedAttr.cpp
index 6d5c6a2..6509df9 100644
--- a/clang/lib/Sema/AttributeList.cpp
+++ b/clang/lib/Sema/ParsedAttr.cpp
@@ -1,4 +1,4 @@
-//===- AttributeList.cpp --------------------------------------------------===//
+//======- ParsedAttr.cpp --------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
@@ -7,11 +7,11 @@
//
//===----------------------------------------------------------------------===//
//
-// This file defines the AttributeList class implementation
+// This file defines the ParsedAttr class implementation
//
//===----------------------------------------------------------------------===//
-#include "clang/Sema/AttributeList.h"
+#include "clang/Sema/ParsedAttr.h"
#include "clang/AST/ASTContext.h"
#include "clang/Basic/AttrSubjectMatchRules.h"
#include "clang/Basic/IdentifierTable.h"
@@ -34,15 +34,15 @@
return Result;
}
-size_t AttributeList::allocated_size() const {
+size_t ParsedAttr::allocated_size() const {
if (IsAvailability) return AttributeFactory::AvailabilityAllocSize;
else if (IsTypeTagForDatatype)
return AttributeFactory::TypeTagForDatatypeAllocSize;
else if (IsProperty)
return AttributeFactory::PropertyAllocSize;
else if (HasParsedType)
- return sizeof(AttributeList) + sizeof(void *);
- return (sizeof(AttributeList) + NumArgs * sizeof(ArgsUnion));
+ return sizeof(ParsedAttr) + sizeof(void *);
+ return (sizeof(ParsedAttr) + NumArgs * sizeof(ArgsUnion));
}
AttributeFactory::AttributeFactory() {
@@ -52,16 +52,16 @@
AttributeFactory::~AttributeFactory() = default;
static size_t getFreeListIndexForSize(size_t size) {
- assert(size >= sizeof(AttributeList));
+ assert(size >= sizeof(ParsedAttr));
assert((size % sizeof(void*)) == 0);
- return ((size - sizeof(AttributeList)) / sizeof(void*));
+ return ((size - sizeof(ParsedAttr)) / sizeof(void *));
}
void *AttributeFactory::allocate(size_t size) {
// Check for a previously reclaimed attribute.
size_t index = getFreeListIndexForSize(size);
if (index < FreeLists.size() && !FreeLists[index].empty()) {
- AttributeList *attr = FreeLists[index].back();
+ ParsedAttr *attr = FreeLists[index].back();
FreeLists[index].pop_back();
return attr;
}
@@ -70,7 +70,7 @@
return Alloc.Allocate(size, alignof(AttributeFactory));
}
-void AttributeFactory::deallocate(AttributeList *Attr) {
+void AttributeFactory::deallocate(ParsedAttr *Attr) {
size_t size = Attr->allocated_size();
size_t freeListIndex = getFreeListIndexForSize(size);
@@ -88,7 +88,7 @@
}
void AttributeFactory::reclaimPool(AttributePool &cur) {
- for (AttributeList *AL : cur.Attrs)
+ for (ParsedAttr *AL : cur.Attrs)
deallocate(AL);
}
@@ -100,12 +100,13 @@
#include "clang/Sema/AttrParsedAttrKinds.inc"
static StringRef normalizeAttrName(StringRef AttrName, StringRef ScopeName,
- AttributeList::Syntax SyntaxUsed) {
+ ParsedAttr::Syntax SyntaxUsed) {
// Normalize the attribute name, __foo__ becomes foo. This is only allowable
// for GNU attributes.
- bool IsGNU = SyntaxUsed == AttributeList::AS_GNU ||
- ((SyntaxUsed == AttributeList::AS_CXX11 ||
- SyntaxUsed == AttributeList::AS_C2x) && ScopeName == "gnu");
+ bool IsGNU = SyntaxUsed == ParsedAttr::AS_GNU ||
+ ((SyntaxUsed == ParsedAttr::AS_CXX11 ||
+ SyntaxUsed == ParsedAttr::AS_C2x) &&
+ ScopeName == "gnu");
if (IsGNU && AttrName.size() >= 4 && AttrName.startswith("__") &&
AttrName.endswith("__"))
AttrName = AttrName.slice(2, AttrName.size() - 2);
@@ -113,9 +114,9 @@
return AttrName;
}
-AttributeList::Kind AttributeList::getKind(const IdentifierInfo *Name,
- const IdentifierInfo *ScopeName,
- Syntax SyntaxUsed) {
+ParsedAttr::Kind ParsedAttr::getKind(const IdentifierInfo *Name,
+ const IdentifierInfo *ScopeName,
+ Syntax SyntaxUsed) {
StringRef AttrName = Name->getName();
SmallString<64> FullName;
@@ -133,12 +134,12 @@
return ::getAttrKind(FullName, SyntaxUsed);
}
-unsigned AttributeList::getAttributeSpellingListIndex() const {
+unsigned ParsedAttr::getAttributeSpellingListIndex() const {
// Both variables will be used in tablegen generated
// attribute spell list index matching code.
StringRef Scope = ScopeName ? ScopeName->getName() : "";
StringRef Name = normalizeAttrName(AttrName->getName(), Scope,
- (AttributeList::Syntax)SyntaxUsed);
+ (ParsedAttr::Syntax)SyntaxUsed);
#include "clang/Sema/AttrSpellingListIndex.inc"
@@ -154,11 +155,10 @@
unsigned IsKnownToGCC : 1;
unsigned IsSupportedByPragmaAttribute : 1;
- bool (*DiagAppertainsToDecl)(Sema &S, const AttributeList &Attr,
- const Decl *);
- bool (*DiagLangOpts)(Sema &S, const AttributeList &Attr);
+ bool (*DiagAppertainsToDecl)(Sema &S, const ParsedAttr &Attr, const Decl *);
+ bool (*DiagLangOpts)(Sema &S, const ParsedAttr &Attr);
bool (*ExistsInTarget)(const TargetInfo &Target);
- unsigned (*SpellingIndexToSemanticSpelling)(const AttributeList &Attr);
+ unsigned (*SpellingIndexToSemanticSpelling)(const ParsedAttr &Attr);
void (*GetPragmaAttributeMatchRules)(
llvm::SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &Rules,
const LangOptions &LangOpts);
@@ -170,71 +170,63 @@
} // namespace
-static const ParsedAttrInfo &getInfo(const AttributeList &A) {
+static const ParsedAttrInfo &getInfo(const ParsedAttr &A) {
return AttrInfoMap[A.getKind()];
}
-unsigned AttributeList::getMinArgs() const {
- return getInfo(*this).NumArgs;
-}
+unsigned ParsedAttr::getMinArgs() const { return getInfo(*this).NumArgs; }
-unsigned AttributeList::getMaxArgs() const {
+unsigned ParsedAttr::getMaxArgs() const {
return getMinArgs() + getInfo(*this).OptArgs;
}
-bool AttributeList::hasCustomParsing() const {
+bool ParsedAttr::hasCustomParsing() const {
return getInfo(*this).HasCustomParsing;
}
-bool AttributeList::diagnoseAppertainsTo(Sema &S, const Decl *D) const {
+bool ParsedAttr::diagnoseAppertainsTo(Sema &S, const Decl *D) const {
return getInfo(*this).DiagAppertainsToDecl(S, *this, D);
}
-bool AttributeList::appliesToDecl(const Decl *D,
- attr::SubjectMatchRule MatchRule) const {
+bool ParsedAttr::appliesToDecl(const Decl *D,
+ attr::SubjectMatchRule MatchRule) const {
return checkAttributeMatchRuleAppliesTo(D, MatchRule);
}
-void AttributeList::getMatchRules(
+void ParsedAttr::getMatchRules(
const LangOptions &LangOpts,
SmallVectorImpl<std::pair<attr::SubjectMatchRule, bool>> &MatchRules)
const {
return getInfo(*this).GetPragmaAttributeMatchRules(MatchRules, LangOpts);
}
-bool AttributeList::diagnoseLangOpts(Sema &S) const {
+bool ParsedAttr::diagnoseLangOpts(Sema &S) const {
return getInfo(*this).DiagLangOpts(S, *this);
}
-bool AttributeList::isTargetSpecificAttr() const {
+bool ParsedAttr::isTargetSpecificAttr() const {
return getInfo(*this).IsTargetSpecific;
}
-bool AttributeList::isTypeAttr() const {
- return getInfo(*this).IsType;
-}
+bool ParsedAttr::isTypeAttr() const { return getInfo(*this).IsType; }
-bool AttributeList::isStmtAttr() const {
- return getInfo(*this).IsStmt;
-}
+bool ParsedAttr::isStmtAttr() const { return getInfo(*this).IsStmt; }
-bool AttributeList::existsInTarget(const TargetInfo &Target) const {
+bool ParsedAttr::existsInTarget(const TargetInfo &Target) const {
return getInfo(*this).ExistsInTarget(Target);
}
-bool AttributeList::isKnownToGCC() const {
- return getInfo(*this).IsKnownToGCC;
-}
+bool ParsedAttr::isKnownToGCC() const { return getInfo(*this).IsKnownToGCC; }
-bool AttributeList::isSupportedByPragmaAttribute() const {
+bool ParsedAttr::isSupportedByPragmaAttribute() const {
return getInfo(*this).IsSupportedByPragmaAttribute;
}
-unsigned AttributeList::getSemanticSpelling() const {
+unsigned ParsedAttr::getSemanticSpelling() const {
return getInfo(*this).SpellingIndexToSemanticSpelling(*this);
}
-bool AttributeList::hasVariadicArg() const {
+bool ParsedAttr::hasVariadicArg() const {
// If the attribute has the maximum number of optional arguments, we will
// claim that as being variadic. If we someday get an attribute that
// legitimately bumps up against that maximum, we can use another bit to track
diff --git a/clang/lib/Sema/SemaAttr.cpp b/clang/lib/Sema/SemaAttr.cpp
index cc155b7..4f3cf46 100644
--- a/clang/lib/Sema/SemaAttr.cpp
+++ b/clang/lib/Sema/SemaAttr.cpp
@@ -520,7 +520,7 @@
} // end anonymous namespace
-void Sema::ActOnPragmaAttributePush(AttributeList &Attribute,
+void Sema::ActOnPragmaAttributePush(ParsedAttr &Attribute,
SourceLocation PragmaLoc,
attr::ParsedSubjectMatchRuleSet Rules) {
SmallVector<attr::SubjectMatchRule, 4> SubjectMatchRules;
@@ -645,7 +645,7 @@
if (PragmaAttributeStack.empty())
return;
for (auto &Entry : PragmaAttributeStack) {
- AttributeList *Attribute = Entry.Attribute;
+ ParsedAttr *Attribute = Entry.Attribute;
assert(Attribute && "Expected an attribute");
// Ensure that the attribute can be applied to the given declaration.
diff --git a/clang/lib/Sema/SemaCUDA.cpp b/clang/lib/Sema/SemaCUDA.cpp
index 5b81eb3..13dd8d9 100644
--- a/clang/lib/Sema/SemaCUDA.cpp
+++ b/clang/lib/Sema/SemaCUDA.cpp
@@ -61,18 +61,18 @@
bool HasDeviceAttr = false;
bool HasGlobalAttr = false;
bool HasInvalidTargetAttr = false;
- for (const AttributeList &AL : Attrs) {
+ for (const ParsedAttr &AL : Attrs) {
switch (AL.getKind()) {
- case AttributeList::AT_CUDAGlobal:
+ case ParsedAttr::AT_CUDAGlobal:
HasGlobalAttr = true;
break;
- case AttributeList::AT_CUDAHost:
+ case ParsedAttr::AT_CUDAHost:
HasHostAttr = true;
break;
- case AttributeList::AT_CUDADevice:
+ case ParsedAttr::AT_CUDADevice:
HasDeviceAttr = true;
break;
- case AttributeList::AT_CUDAInvalidTarget:
+ case ParsedAttr::AT_CUDAInvalidTarget:
HasInvalidTargetAttr = true;
break;
default:
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 1e63fd3..a754cc9 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -4447,7 +4447,7 @@
TypeSpecType == DeclSpec::TST_interface ||
TypeSpecType == DeclSpec::TST_union ||
TypeSpecType == DeclSpec::TST_enum) {
- for (const AttributeList &AL : DS.getAttributes())
+ for (const ParsedAttr &AL : DS.getAttributes())
Diag(AL.getLoc(), diag::warn_declspec_attribute_ignored)
<< AL.getName() << GetDiagnosticTypeSpecifierID(TypeSpecType);
}
@@ -6204,7 +6204,7 @@
}
static bool hasParsedAttr(Scope *S, const Declarator &PD,
- AttributeList::Kind Kind) {
+ ParsedAttr::Kind Kind) {
// Check decl attributes on the DeclSpec.
if (PD.getDeclSpec().getAttributes().hasAttribute(Kind))
return true;
@@ -6372,8 +6372,8 @@
// dllimport globals without explicit storage class are treated as extern. We
// have to change the storage class this early to get the right DeclContext.
if (SC == SC_None && !DC->isRecord() &&
- hasParsedAttr(S, D, AttributeList::AT_DLLImport) &&
- !hasParsedAttr(S, D, AttributeList::AT_DLLExport))
+ hasParsedAttr(S, D, ParsedAttr::AT_DLLImport) &&
+ !hasParsedAttr(S, D, ParsedAttr::AT_DLLExport))
SC = SC_Extern;
DeclContext *OriginalDC = DC;
diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
index d352015..47ef872 100644
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -172,13 +172,13 @@
return RD->getIdentifier() == &Ctx.Idents.get("__CFString");
}
-static unsigned getNumAttributeArgs(const AttributeList &AL) {
+static unsigned getNumAttributeArgs(const ParsedAttr &AL) {
// FIXME: Include the type in the argument list.
return AL.getNumArgs() + AL.hasParsedType();
}
template <typename Compare>
-static bool checkAttributeNumArgsImpl(Sema &S, const AttributeList &AL,
+static bool checkAttributeNumArgsImpl(Sema &S, const ParsedAttr &AL,
unsigned Num, unsigned Diag,
Compare Comp) {
if (Comp(getNumAttributeArgs(AL), Num)) {
@@ -191,8 +191,7 @@
/// Check if the attribute has exactly as many args as Num. May
/// output an error.
-static bool checkAttributeNumArgs(Sema &S, const AttributeList &AL,
- unsigned Num) {
+static bool checkAttributeNumArgs(Sema &S, const ParsedAttr &AL, unsigned Num) {
return checkAttributeNumArgsImpl(S, AL, Num,
diag::err_attribute_wrong_number_arguments,
std::not_equal_to<unsigned>());
@@ -200,7 +199,7 @@
/// Check if the attribute has at least as many args as Num. May
/// output an error.
-static bool checkAttributeAtLeastNumArgs(Sema &S, const AttributeList &AL,
+static bool checkAttributeAtLeastNumArgs(Sema &S, const ParsedAttr &AL,
unsigned Num) {
return checkAttributeNumArgsImpl(S, AL, Num,
diag::err_attribute_too_few_arguments,
@@ -209,34 +208,32 @@
/// Check if the attribute has at most as many args as Num. May
/// output an error.
-static bool checkAttributeAtMostNumArgs(Sema &S, const AttributeList &AL,
- unsigned Num) {
+static bool checkAttributeAtMostNumArgs(Sema &S, const ParsedAttr &AL,
+ unsigned Num) {
return checkAttributeNumArgsImpl(S, AL, Num,
diag::err_attribute_too_many_arguments,
std::greater<unsigned>());
}
/// A helper function to provide Attribute Location for the Attr types
-/// AND the AttributeList.
+/// AND the ParsedAttr.
template <typename AttrInfo>
static typename std::enable_if<std::is_base_of<Attr, AttrInfo>::value,
SourceLocation>::type
getAttrLoc(const AttrInfo &AL) {
return AL.getLocation();
}
-static SourceLocation getAttrLoc(const AttributeList &AL) {
- return AL.getLoc();
-}
+static SourceLocation getAttrLoc(const ParsedAttr &AL) { return AL.getLoc(); }
/// A helper function to provide Attribute Name for the Attr types
-/// AND the AttributeList.
+/// AND the ParsedAttr.
template <typename AttrInfo>
static typename std::enable_if<std::is_base_of<Attr, AttrInfo>::value,
const AttrInfo *>::type
getAttrName(const AttrInfo &AL) {
return &AL;
}
-static const IdentifierInfo *getAttrName(const AttributeList &AL) {
+static const IdentifierInfo *getAttrName(const ParsedAttr &AL) {
return AL.getName();
}
@@ -355,8 +352,8 @@
/// If not emit an error and return false. If the argument is an identifier it
/// will emit an error with a fixit hint and treat it as if it was a string
/// literal.
-bool Sema::checkStringLiteralArgumentAttr(const AttributeList &AL,
- unsigned ArgNum, StringRef &Str,
+bool Sema::checkStringLiteralArgumentAttr(const ParsedAttr &AL, unsigned ArgNum,
+ StringRef &Str,
SourceLocation *ArgLocation) {
// Look for identifiers. If we have one emit a hint to fix it to a literal.
if (AL.isArgIdent(ArgNum)) {
@@ -390,14 +387,14 @@
/// Applies the given attribute to the Decl without performing any
/// additional semantic checking.
template <typename AttrType>
-static void handleSimpleAttribute(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleSimpleAttribute(Sema &S, Decl *D, const ParsedAttr &AL) {
D->addAttr(::new (S.Context) AttrType(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
}
template <typename AttrType>
static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
handleSimpleAttribute<AttrType>(S, D, AL);
}
@@ -406,7 +403,7 @@
template <typename AttrType, typename IncompatibleAttrType,
typename... IncompatibleAttrTypes>
static void handleSimpleAttributeWithExclusions(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
if (checkAttrMutualExclusion<IncompatibleAttrType>(S, D, AL.getRange(),
AL.getName()))
return;
@@ -441,7 +438,7 @@
/// Note that this function may produce an error message.
/// \return true if the Decl is a pointer type; false otherwise
static bool threadSafetyCheckIsPointer(Sema &S, const Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
const auto *VD = cast<ValueDecl>(D);
QualType QT = VD->getType();
if (QT->isAnyPointerType())
@@ -561,7 +558,7 @@
/// \param ParamIdxOk Whether an argument can be indexing into a function
/// parameter list.
static void checkAttrArgsAreCapabilityObjs(Sema &S, Decl *D,
- const AttributeList &AL,
+ const ParsedAttr &AL,
SmallVectorImpl<Expr *> &Args,
int Sidx = 0,
bool ParamIdxOk = false) {
@@ -637,8 +634,7 @@
// Attribute Implementations
//===----------------------------------------------------------------------===//
-static void handlePtGuardedVarAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handlePtGuardedVarAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!threadSafetyCheckIsPointer(S, D, AL))
return;
@@ -647,7 +643,7 @@
AL.getAttributeSpellingListIndex()));
}
-static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const AttributeList &AL,
+static bool checkGuardedByAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
Expr *&Arg) {
SmallVector<Expr *, 1> Args;
// check that all arguments are lockable objects
@@ -661,7 +657,7 @@
return true;
}
-static void handleGuardedByAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *Arg = nullptr;
if (!checkGuardedByAttrCommon(S, D, AL, Arg))
return;
@@ -670,8 +666,7 @@
AL.getRange(), S.Context, Arg, AL.getAttributeSpellingListIndex()));
}
-static void handlePtGuardedByAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handlePtGuardedByAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *Arg = nullptr;
if (!checkGuardedByAttrCommon(S, D, AL, Arg))
return;
@@ -683,8 +678,7 @@
AL.getRange(), S.Context, Arg, AL.getAttributeSpellingListIndex()));
}
-static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D,
- const AttributeList &AL,
+static bool checkAcquireOrderAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
SmallVectorImpl<Expr *> &Args) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
return false;
@@ -705,8 +699,7 @@
return true;
}
-static void handleAcquiredAfterAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAcquiredAfterAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
SmallVector<Expr *, 1> Args;
if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
return;
@@ -717,8 +710,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleAcquiredBeforeAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAcquiredBeforeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
SmallVector<Expr *, 1> Args;
if (!checkAcquireOrderAttrCommon(S, D, AL, Args))
return;
@@ -729,8 +721,7 @@
AL.getAttributeSpellingListIndex()));
}
-static bool checkLockFunAttrCommon(Sema &S, Decl *D,
- const AttributeList &AL,
+static bool checkLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
SmallVectorImpl<Expr *> &Args) {
// zero or more arguments ok
// check that all arguments are lockable objects
@@ -739,8 +730,7 @@
return true;
}
-static void handleAssertSharedLockAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAssertSharedLockAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
SmallVector<Expr *, 1> Args;
if (!checkLockFunAttrCommon(S, D, AL, Args))
return;
@@ -753,7 +743,7 @@
}
static void handleAssertExclusiveLockAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
SmallVector<Expr *, 1> Args;
if (!checkLockFunAttrCommon(S, D, AL, Args))
return;
@@ -790,7 +780,7 @@
return true;
}
-static void handleAllocSizeAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleAllocSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
!checkAttributeAtMostNumArgs(S, AL, 2))
return;
@@ -828,8 +818,7 @@
AL.getAttributeSpellingListIndex()));
}
-static bool checkTryLockFunAttrCommon(Sema &S, Decl *D,
- const AttributeList &AL,
+static bool checkTryLockFunAttrCommon(Sema &S, Decl *D, const ParsedAttr &AL,
SmallVectorImpl<Expr *> &Args) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
return false;
@@ -847,7 +836,7 @@
}
static void handleSharedTrylockFunctionAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
SmallVector<Expr*, 2> Args;
if (!checkTryLockFunAttrCommon(S, D, AL, Args))
return;
@@ -858,7 +847,7 @@
}
static void handleExclusiveTrylockFunctionAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
SmallVector<Expr*, 2> Args;
if (!checkTryLockFunAttrCommon(S, D, AL, Args))
return;
@@ -868,8 +857,7 @@
Args.size(), AL.getAttributeSpellingListIndex()));
}
-static void handleLockReturnedAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleLockReturnedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// check that the argument is lockable object
SmallVector<Expr*, 1> Args;
checkAttrArgsAreCapabilityObjs(S, D, AL, Args);
@@ -882,8 +870,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleLocksExcludedAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleLocksExcludedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
return;
@@ -900,8 +887,7 @@
AL.getAttributeSpellingListIndex()));
}
-static bool checkFunctionConditionAttr(Sema &S, Decl *D,
- const AttributeList &AL,
+static bool checkFunctionConditionAttr(Sema &S, Decl *D, const ParsedAttr &AL,
Expr *&Cond, StringRef &Msg) {
Cond = AL.getArgAsExpr(0);
if (!Cond->isTypeDependent()) {
@@ -930,7 +916,7 @@
return true;
}
-static void handleEnableIfAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleEnableIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
S.Diag(AL.getLoc(), diag::ext_clang_enable_if);
Expr *Cond;
@@ -987,7 +973,7 @@
};
}
-static void handleDiagnoseIfAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleDiagnoseIfAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
S.Diag(AL.getLoc(), diag::ext_clang_diagnose_if);
Expr *Cond;
@@ -1014,8 +1000,7 @@
cast<NamedDecl>(D), AL.getAttributeSpellingListIndex()));
}
-static void handlePassObjectSizeAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handlePassObjectSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (D->hasAttr<PassObjectSizeAttr>()) {
S.Diag(D->getLocStart(), diag::err_attribute_only_once_per_parameter)
<< AL.getName();
@@ -1050,7 +1035,7 @@
AL.getRange(), S.Context, (int)Type, AL.getAttributeSpellingListIndex()));
}
-static void handleConsumableAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleConsumableAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
ConsumableAttr::ConsumedState DefaultState;
if (AL.isArgIdent(0)) {
@@ -1073,7 +1058,7 @@
}
static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
ASTContext &CurrContext = S.getASTContext();
QualType ThisType = MD->getThisType(CurrContext)->getPointeeType();
@@ -1089,8 +1074,7 @@
return true;
}
-static void handleCallableWhenAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleCallableWhenAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
return;
@@ -1127,8 +1111,7 @@
States.size(), AL.getAttributeSpellingListIndex()));
}
-static void handleParamTypestateAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleParamTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
ParamTypestateAttr::ConsumedState ParamState;
if (AL.isArgIdent(0)) {
@@ -1164,8 +1147,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleReturnTypestateAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleReturnTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
ReturnTypestateAttr::ConsumedState ReturnState;
if (AL.isArgIdent(0)) {
@@ -1212,7 +1194,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleSetTypestateAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleSetTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
return;
@@ -1236,8 +1218,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleTestTypestateAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleTestTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkForConsumableClass(S, cast<CXXMethodDecl>(D), AL))
return;
@@ -1261,12 +1242,12 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleExtVectorTypeAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleExtVectorTypeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Remember this typedef decl, we will need it later for diagnostics.
S.ExtVectorDecls.push_back(cast<TypedefNameDecl>(D));
}
-static void handlePackedAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (auto *TD = dyn_cast<TagDecl>(D))
TD->addAttr(::new (S.Context) PackedAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
@@ -1297,7 +1278,7 @@
S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL.getName();
}
-static bool checkIBOutletCommon(Sema &S, Decl *D, const AttributeList &AL) {
+static bool checkIBOutletCommon(Sema &S, Decl *D, const ParsedAttr &AL) {
// The IBOutlet/IBOutletCollection attributes only apply to instance
// variables or properties of Objective-C classes. The outlet must also
// have an object reference type.
@@ -1323,7 +1304,7 @@
return true;
}
-static void handleIBOutlet(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleIBOutlet(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkIBOutletCommon(S, D, AL))
return;
@@ -1332,8 +1313,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleIBOutletCollection(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleIBOutletCollection(Sema &S, Decl *D, const ParsedAttr &AL) {
// The iboutletcollection attribute can have zero or one arguments.
if (AL.getNumArgs() > 1) {
@@ -1403,7 +1383,7 @@
return T->isAnyPointerType() || T->isBlockPointerType();
}
-static bool attrNonNullArgCheck(Sema &S, QualType T, const AttributeList &AL,
+static bool attrNonNullArgCheck(Sema &S, QualType T, const ParsedAttr &AL,
SourceRange AttrParmRange,
SourceRange TypeRange,
bool isReturnValue = false) {
@@ -1419,7 +1399,7 @@
return true;
}
-static void handleNonNullAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
SmallVector<ParamIdx, 8> NonNullArgs;
for (unsigned I = 0; I < AL.getNumArgs(); ++I) {
Expr *Ex = AL.getArgAsExpr(I);
@@ -1465,7 +1445,7 @@
}
static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
if (AL.getNumArgs() > 0) {
if (D->getFunctionType()) {
handleNonNullAttr(S, D, AL);
@@ -1486,8 +1466,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleReturnsNonNullAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleReturnsNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
QualType ResultType = getFunctionOrMethodResultType(D);
SourceRange SR = getFunctionOrMethodResultSourceRange(D);
if (!attrNonNullArgCheck(S, ResultType, AL, SourceRange(), SR,
@@ -1499,7 +1478,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleNoEscapeAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleNoEscapeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (D->isInvalidDecl())
return;
@@ -1515,16 +1494,14 @@
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
}
-static void handleAssumeAlignedAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAssumeAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *E = AL.getArgAsExpr(0),
*OE = AL.getNumArgs() > 1 ? AL.getArgAsExpr(1) : nullptr;
S.AddAssumeAlignedAttr(AL.getRange(), D, E, OE,
AL.getAttributeSpellingListIndex());
}
-static void handleAllocAlignAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAllocAlignAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
S.AddAllocAlignAttr(AL.getRange(), D, AL.getArgAsExpr(0),
AL.getAttributeSpellingListIndex());
}
@@ -1623,7 +1600,7 @@
return false;
}
-static void handleOwnershipAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// This attribute must be applied to a function declaration. The first
// argument to the attribute must be an identifier, the name of the resource,
// for example: malloc. The following arguments must be argument indexes, the
@@ -1730,7 +1707,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleWeakRefAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleWeakRefAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Check the attribute arguments.
if (AL.getNumArgs() > 1) {
S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
@@ -1792,7 +1769,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleIFuncAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef Str;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
return;
@@ -1808,7 +1785,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleAliasAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef Str;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
return;
@@ -1841,8 +1818,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleTLSModelAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef Model;
SourceLocation LiteralLoc;
// Check that it is a string.
@@ -1861,7 +1837,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleRestrictAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
QualType ResultType = getFunctionOrMethodResultType(D);
if (ResultType->isAnyPointerType() || ResultType->isBlockPointerType()) {
D->addAttr(::new (S.Context) RestrictAttr(
@@ -1873,7 +1849,7 @@
<< AL.getName() << getFunctionOrMethodResultSourceRange(D);
}
-static void handleCommonAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleCommonAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (S.LangOpts.CPlusPlus) {
S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
<< AL.getName() << AttributeLangSupport::Cpp;
@@ -1885,7 +1861,7 @@
D->addAttr(CA);
}
-static void handleNakedAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleNakedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<DisableTailCallsAttr>(S, D, AL.getRange(),
AL.getName()))
return;
@@ -1905,7 +1881,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleNoReturnAttr(Sema &S, Decl *D, const AttributeList &Attrs) {
+static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
if (hasDeclarator(D)) return;
if (!isa<ObjCMethodDecl>(D)) {
@@ -1918,14 +1894,14 @@
Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
}
-static void handleNoCfCheckAttr(Sema &S, Decl *D, const AttributeList &Attrs) {
+static void handleNoCfCheckAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
if (!S.getLangOpts().CFProtectionBranch)
S.Diag(Attrs.getLoc(), diag::warn_nocf_check_attribute_ignored);
else
handleSimpleAttribute<AnyX86NoCfCheckAttr>(S, D, Attrs);
}
-bool Sema::CheckAttrNoArgs(const AttributeList &Attrs) {
+bool Sema::CheckAttrNoArgs(const ParsedAttr &Attrs) {
if (!checkAttributeNumArgs(*this, Attrs, 0)) {
Attrs.setInvalid();
return true;
@@ -1934,7 +1910,7 @@
return false;
}
-bool Sema::CheckAttrTarget(const AttributeList &AL) {
+bool Sema::CheckAttrTarget(const ParsedAttr &AL) {
// Check whether the attribute is valid on the current target.
if (!AL.existsInTarget(Context.getTargetInfo())) {
Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored) << AL.getName();
@@ -1945,9 +1921,8 @@
return false;
}
-static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
-
+static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+
// The checking path for 'noreturn' and 'analyzer_noreturn' are different
// because 'analyzer_noreturn' does not impact the type.
if (!isFunctionOrMethodOrBlock(D)) {
@@ -1968,30 +1943,31 @@
}
// PS3 PPU-specific.
-static void handleVecReturnAttr(Sema &S, Decl *D, const AttributeList &AL) {
-/*
- Returning a Vector Class in Registers
-
- According to the PPU ABI specifications, a class with a single member of
- vector type is returned in memory when used as the return value of a function.
- This results in inefficient code when implementing vector classes. To return
- the value in a single vector register, add the vecreturn attribute to the
- class definition. This attribute is also applicable to struct types.
-
- Example:
-
- struct Vector
- {
- __vector float xyzw;
- } __attribute__((vecreturn));
-
- Vector Add(Vector lhs, Vector rhs)
- {
- Vector result;
- result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
- return result; // This will be returned in a register
- }
-*/
+static void handleVecReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+ /*
+ Returning a Vector Class in Registers
+
+ According to the PPU ABI specifications, a class with a single member of
+ vector type is returned in memory when used as the return value of a
+ function.
+ This results in inefficient code when implementing vector classes. To return
+ the value in a single vector register, add the vecreturn attribute to the
+ class definition. This attribute is also applicable to struct types.
+
+ Example:
+
+ struct Vector
+ {
+ __vector float xyzw;
+ } __attribute__((vecreturn));
+
+ Vector Add(Vector lhs, Vector rhs)
+ {
+ Vector result;
+ result.xyzw = vec_add(lhs.xyzw, rhs.xyzw);
+ return result; // This will be returned in a register
+ }
+ */
if (VecReturnAttr *A = D->getAttr<VecReturnAttr>()) {
S.Diag(AL.getLoc(), diag::err_repeat_attribute) << A;
return;
@@ -2023,7 +1999,7 @@
}
static void handleDependencyAttr(Sema &S, Scope *Scope, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
if (isa<ParmVarDecl>(D)) {
// [[carries_dependency]] can only be applied to a parameter if it is a
// parameter of a function declaration or lambda.
@@ -2039,7 +2015,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleUnusedAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleUnusedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
bool IsCXX17Attr = AL.isCXX11Attribute() && !AL.getScopeName();
// If this is spelled as the standard C++17 attribute, but not in C++17, warn
@@ -2051,7 +2027,7 @@
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
}
-static void handleConstructorAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t priority = ConstructorAttr::DefaultPriority;
if (AL.getNumArgs() &&
!checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
@@ -2062,7 +2038,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleDestructorAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleDestructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t priority = DestructorAttr::DefaultPriority;
if (AL.getNumArgs() &&
!checkUInt32Argument(S, AL, AL.getArgAsExpr(0), priority))
@@ -2074,8 +2050,7 @@
}
template <typename AttrTy>
-static void handleAttrWithMessage(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAttrWithMessage(Sema &S, Decl *D, const ParsedAttr &AL) {
// Handle the case where the attribute has a text message.
StringRef Str;
if (AL.getNumArgs() == 1 && !S.checkStringLiteralArgumentAttr(AL, 0, Str))
@@ -2086,7 +2061,7 @@
}
static void handleObjCSuppresProtocolAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
if (!cast<ObjCProtocolDecl>(D)->isThisDeclarationADefinition()) {
S.Diag(AL.getLoc(), diag::err_objc_attr_protocol_requires_definition)
<< AL.getName() << AL.getRange();
@@ -2319,8 +2294,7 @@
return nullptr;
}
-static void handleAvailabilityAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeNumArgs(S, AL, 1))
return;
IdentifierLoc *Platform = AL.getArgAsIdent(0);
@@ -2435,7 +2409,7 @@
}
static void handleExternalSourceSymbolAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
return;
assert(checkAttributeAtMostNumArgs(S, AL, 3) &&
@@ -2484,7 +2458,7 @@
AttrSpellingListIndex);
}
-static void handleVisibilityAttr(Sema &S, Decl *D, const AttributeList &AL,
+static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL,
bool isTypeVisibility) {
// Visibility attributes don't mean anything on a typedef.
if (isa<TypedefNameDecl>(D)) {
@@ -2537,8 +2511,7 @@
D->addAttr(newAttr);
}
-static void handleObjCMethodFamilyAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleObjCMethodFamilyAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
const auto *M = cast<ObjCMethodDecl>(D);
if (!AL.isArgIdent(0)) {
S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
@@ -2566,7 +2539,7 @@
AL.getRange(), S.Context, F, AL.getAttributeSpellingListIndex()));
}
-static void handleObjCNSObject(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleObjCNSObject(Sema &S, Decl *D, const ParsedAttr &AL) {
if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
QualType T = TD->getUnderlyingType();
if (!T->isCARCBridgableType()) {
@@ -2595,7 +2568,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleObjCIndependentClass(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleObjCIndependentClass(Sema &S, Decl *D, const ParsedAttr &AL) {
if (const auto *TD = dyn_cast<TypedefNameDecl>(D)) {
QualType T = TD->getUnderlyingType();
if (!T->isObjCObjectPointerType()) {
@@ -2611,7 +2584,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleBlocksAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleBlocksAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
<< AL.getName() << 1 << AANT_ArgumentIdentifier;
@@ -2631,7 +2604,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleSentinelAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
unsigned sentinel = (unsigned)SentinelAttr::DefaultSentinel;
if (AL.getNumArgs() > 0) {
Expr *E = AL.getArgAsExpr(0);
@@ -2722,7 +2695,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleWarnUnusedResult(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {
if (D->getFunctionType() &&
D->getFunctionType()->getReturnType()->isVoidType()) {
S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method)
@@ -2747,7 +2720,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleWeakImportAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// weak_import only applies to variable & function declarations.
bool isDef = false;
if (!D->canBeWeakImported(isDef)) {
@@ -2772,8 +2745,7 @@
// Handles reqd_work_group_size and work_group_size_hint.
template <typename WorkGroupAttr>
-static void handleWorkGroupSize(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleWorkGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t WGSize[3];
for (unsigned i = 0; i < 3; ++i) {
const Expr *E = AL.getArgAsExpr(i);
@@ -2798,7 +2770,7 @@
}
// Handles intel_reqd_sub_group_size.
-static void handleSubGroupSize(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleSubGroupSize(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t SGSize;
const Expr *E = AL.getArgAsExpr(0);
if (!checkUInt32Argument(S, AL, E, SGSize))
@@ -2819,7 +2791,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleVecTypeHint(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleVecTypeHint(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!AL.hasParsedType()) {
S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
<< AL.getName() << 1;
@@ -2873,7 +2845,7 @@
return true;
}
-static void handleSectionAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleSectionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Make sure that there is a string literal as the sections's single
// argument.
StringRef Str;
@@ -2929,7 +2901,7 @@
return false;
}
-static void handleTargetAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleTargetAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef Str;
SourceLocation LiteralLoc;
if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &LiteralLoc) ||
@@ -2942,7 +2914,7 @@
D->addAttr(NewAttr);
}
-static void handleMinVectorWidthAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleMinVectorWidthAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *E = AL.getArgAsExpr(0);
uint32_t VecWidth;
if (!checkUInt32Argument(S, AL, E, VecWidth)) {
@@ -2961,7 +2933,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleCleanupAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *E = AL.getArgAsExpr(0);
SourceLocation Loc = E->getExprLoc();
FunctionDecl *FD = nullptr;
@@ -3019,7 +2991,7 @@
}
static void handleEnumExtensibilityAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
<< AL.getName() << 0 << AANT_ArgumentIdentifier;
@@ -3042,7 +3014,7 @@
/// Handle __attribute__((format_arg((idx)))) attribute based on
/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
-static void handleFormatArgAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleFormatArgAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
Expr *IdxExpr = AL.getArgAsExpr(0);
ParamIdx Idx;
if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, IdxExpr, Idx))
@@ -3108,8 +3080,7 @@
/// Handle __attribute__((init_priority(priority))) attributes based on
/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html
-static void handleInitPriorityAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!S.getLangOpts().CPlusPlus) {
S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL.getName();
return;
@@ -3170,7 +3141,7 @@
/// Handle __attribute__((format(type,idx,firstarg))) attributes based on
/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
-static void handleFormatAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleFormatAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
<< AL.getName() << 1 << AANT_ArgumentIdentifier;
@@ -3292,8 +3263,7 @@
D->addAttr(NewAttr);
}
-static void handleTransparentUnionAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Try to find the underlying union declaration.
RecordDecl *RD = nullptr;
const auto *TD = dyn_cast<TypedefNameDecl>(D);
@@ -3366,7 +3336,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleAnnotateAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleAnnotateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Make sure that there is a string literal as the annotation's single
// argument.
StringRef Str;
@@ -3384,8 +3354,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleAlignValueAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAlignValueAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
S.AddAlignValueAttr(AL.getRange(), D, AL.getArgAsExpr(0),
AL.getAttributeSpellingListIndex());
}
@@ -3435,7 +3404,7 @@
D->addAttr(::new (Context) AlignValueAttr(TmpAttr));
}
-static void handleAlignedAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleAlignedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// check the attribute arguments.
if (AL.getNumArgs() > 1) {
S.Diag(AL.getLoc(), diag::err_attribute_wrong_number_arguments)
@@ -3715,7 +3684,7 @@
/// Despite what would be logical, the mode attribute is a decl attribute, not a
/// type attribute: 'int ** __attribute((mode(HI))) *G;' tries to make 'G' be
/// HImode, not an intermediate pointer.
-static void handleModeAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleModeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// This attribute isn't documented, but glibc uses it. It changes
// the width of an int or unsigned int to the specified size.
if (!AL.isArgIdent(0)) {
@@ -3871,7 +3840,7 @@
ModeAttr(AttrRange, Context, Name, SpellingListIndex));
}
-static void handleNoDebugAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleNoDebugAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
D->addAttr(::new (S.Context)
NoDebugAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
@@ -3963,8 +3932,7 @@
AttrSpellingListIndex);
}
-static void handleAlwaysInlineAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAlwaysInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<NotTailCalledAttr>(S, D, AL.getRange(),
AL.getName()))
return;
@@ -3975,20 +3943,19 @@
D->addAttr(Inline);
}
-static void handleMinSizeAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleMinSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (MinSizeAttr *MinSize = S.mergeMinSizeAttr(
D, AL.getRange(), AL.getAttributeSpellingListIndex()))
D->addAttr(MinSize);
}
-static void handleOptimizeNoneAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleOptimizeNoneAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (OptimizeNoneAttr *Optnone = S.mergeOptimizeNoneAttr(
D, AL.getRange(), AL.getAttributeSpellingListIndex()))
D->addAttr(Optnone);
}
-static void handleConstantAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleConstantAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<CUDASharedAttr>(S, D, AL.getRange(),
AL.getName()))
return;
@@ -4001,7 +3968,7 @@
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
}
-static void handleSharedAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleSharedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<CUDAConstantAttr>(S, D, AL.getRange(),
AL.getName()))
return;
@@ -4021,7 +3988,7 @@
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
}
-static void handleGlobalAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleGlobalAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (checkAttrMutualExclusion<CUDADeviceAttr>(S, D, AL.getRange(),
AL.getName()) ||
checkAttrMutualExclusion<CUDAHostAttr>(S, D, AL.getRange(),
@@ -4054,7 +4021,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleGNUInlineAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleGNUInlineAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
const auto *Fn = cast<FunctionDecl>(D);
if (!Fn->isInlineSpecified()) {
S.Diag(AL.getLoc(), diag::warn_gnu_inline_attribute_requires_inline);
@@ -4066,7 +4033,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleCallConvAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (hasDeclarator(D)) return;
// Diagnostic is emitted elsewhere: here we store the (valid) AL
@@ -4082,56 +4049,56 @@
}
switch (AL.getKind()) {
- case AttributeList::AT_FastCall:
+ case ParsedAttr::AT_FastCall:
D->addAttr(::new (S.Context)
FastCallAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_StdCall:
+ case ParsedAttr::AT_StdCall:
D->addAttr(::new (S.Context)
StdCallAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_ThisCall:
+ case ParsedAttr::AT_ThisCall:
D->addAttr(::new (S.Context)
ThisCallAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_CDecl:
+ case ParsedAttr::AT_CDecl:
D->addAttr(::new (S.Context)
CDeclAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_Pascal:
+ case ParsedAttr::AT_Pascal:
D->addAttr(::new (S.Context)
PascalAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_SwiftCall:
+ case ParsedAttr::AT_SwiftCall:
D->addAttr(::new (S.Context)
SwiftCallAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_VectorCall:
+ case ParsedAttr::AT_VectorCall:
D->addAttr(::new (S.Context)
VectorCallAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_MSABI:
+ case ParsedAttr::AT_MSABI:
D->addAttr(::new (S.Context)
MSABIAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_SysVABI:
+ case ParsedAttr::AT_SysVABI:
D->addAttr(::new (S.Context)
SysVABIAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_RegCall:
+ case ParsedAttr::AT_RegCall:
D->addAttr(::new (S.Context) RegCallAttr(
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_Pcs: {
+ case ParsedAttr::AT_Pcs: {
PcsAttr::PCSType PCS;
switch (CC) {
case CC_AAPCS:
@@ -4149,16 +4116,16 @@
AL.getAttributeSpellingListIndex()));
return;
}
- case AttributeList::AT_IntelOclBicc:
+ case ParsedAttr::AT_IntelOclBicc:
D->addAttr(::new (S.Context)
IntelOclBiccAttr(AL.getRange(), S.Context,
AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_PreserveMost:
+ case ParsedAttr::AT_PreserveMost:
D->addAttr(::new (S.Context) PreserveMostAttr(
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_PreserveAll:
+ case ParsedAttr::AT_PreserveAll:
D->addAttr(::new (S.Context) PreserveAllAttr(
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
return;
@@ -4167,7 +4134,7 @@
}
}
-static void handleSuppressAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleSuppressAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
return;
@@ -4187,7 +4154,7 @@
DiagnosticIdentifiers.size(), AL.getAttributeSpellingListIndex()));
}
-bool Sema::CheckCallingConvAttr(const AttributeList &Attrs, CallingConv &CC,
+bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC,
const FunctionDecl *FD) {
if (Attrs.isInvalid())
return true;
@@ -4197,7 +4164,7 @@
return false;
}
- unsigned ReqArgs = Attrs.getKind() == AttributeList::AT_Pcs ? 1 : 0;
+ unsigned ReqArgs = Attrs.getKind() == ParsedAttr::AT_Pcs ? 1 : 0;
if (!checkAttributeNumArgs(*this, Attrs, ReqArgs)) {
Attrs.setInvalid();
return true;
@@ -4205,23 +4172,39 @@
// TODO: diagnose uses of these conventions on the wrong target.
switch (Attrs.getKind()) {
- case AttributeList::AT_CDecl: CC = CC_C; break;
- case AttributeList::AT_FastCall: CC = CC_X86FastCall; break;
- case AttributeList::AT_StdCall: CC = CC_X86StdCall; break;
- case AttributeList::AT_ThisCall: CC = CC_X86ThisCall; break;
- case AttributeList::AT_Pascal: CC = CC_X86Pascal; break;
- case AttributeList::AT_SwiftCall: CC = CC_Swift; break;
- case AttributeList::AT_VectorCall: CC = CC_X86VectorCall; break;
- case AttributeList::AT_RegCall: CC = CC_X86RegCall; break;
- case AttributeList::AT_MSABI:
+ case ParsedAttr::AT_CDecl:
+ CC = CC_C;
+ break;
+ case ParsedAttr::AT_FastCall:
+ CC = CC_X86FastCall;
+ break;
+ case ParsedAttr::AT_StdCall:
+ CC = CC_X86StdCall;
+ break;
+ case ParsedAttr::AT_ThisCall:
+ CC = CC_X86ThisCall;
+ break;
+ case ParsedAttr::AT_Pascal:
+ CC = CC_X86Pascal;
+ break;
+ case ParsedAttr::AT_SwiftCall:
+ CC = CC_Swift;
+ break;
+ case ParsedAttr::AT_VectorCall:
+ CC = CC_X86VectorCall;
+ break;
+ case ParsedAttr::AT_RegCall:
+ CC = CC_X86RegCall;
+ break;
+ case ParsedAttr::AT_MSABI:
CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_C :
CC_Win64;
break;
- case AttributeList::AT_SysVABI:
+ case ParsedAttr::AT_SysVABI:
CC = Context.getTargetInfo().getTriple().isOSWindows() ? CC_X86_64SysV :
CC_C;
break;
- case AttributeList::AT_Pcs: {
+ case ParsedAttr::AT_Pcs: {
StringRef StrRef;
if (!checkStringLiteralArgumentAttr(Attrs, 0, StrRef)) {
Attrs.setInvalid();
@@ -4239,9 +4222,15 @@
Diag(Attrs.getLoc(), diag::err_invalid_pcs);
return true;
}
- case AttributeList::AT_IntelOclBicc: CC = CC_IntelOclBicc; break;
- case AttributeList::AT_PreserveMost: CC = CC_PreserveMost; break;
- case AttributeList::AT_PreserveAll: CC = CC_PreserveAll; break;
+ case ParsedAttr::AT_IntelOclBicc:
+ CC = CC_IntelOclBicc;
+ break;
+ case ParsedAttr::AT_PreserveMost:
+ CC = CC_PreserveMost;
+ break;
+ case ParsedAttr::AT_PreserveAll:
+ CC = CC_PreserveAll;
+ break;
default: llvm_unreachable("unexpected attribute kind");
}
@@ -4298,7 +4287,7 @@
return isValidSwiftContextType(Ty);
}
-static void handleParameterABIAttr(Sema &S, Decl *D, const AttributeList &Attrs,
+static void handleParameterABIAttr(Sema &S, Decl *D, const ParsedAttr &Attrs,
ParameterABI Abi) {
S.AddParameterABIAttr(Attrs.getRange(), D, Abi,
Attrs.getAttributeSpellingListIndex());
@@ -4357,7 +4346,7 @@
/// Checks a regparm attribute, returning true if it is ill-formed and
/// otherwise setting numParams to the appropriate value.
-bool Sema::CheckRegparmAttr(const AttributeList &AL, unsigned &numParams) {
+bool Sema::CheckRegparmAttr(const ParsedAttr &AL, unsigned &numParams) {
if (AL.isInvalid())
return true;
@@ -4450,8 +4439,7 @@
AttrRange, Context, MaxThreads, MinBlocks, SpellingListIndex));
}
-static void handleLaunchBoundsAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleLaunchBoundsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1) ||
!checkAttributeAtMostNumArgs(S, AL, 2))
return;
@@ -4462,7 +4450,7 @@
}
static void handleArgumentWithTypeTagAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
<< AL.getName() << /* arg num = */ 1 << AANT_ArgumentIdentifier;
@@ -4495,7 +4483,7 @@
}
static void handleTypeTagForDatatypeAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
if (!AL.isArgIdent(0)) {
S.Diag(AL.getLoc(), diag::err_attribute_argument_n_type)
<< AL.getName() << 1 << AANT_ArgumentIdentifier;
@@ -4524,7 +4512,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleXRayLogArgsAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleXRayLogArgsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
ParamIdx ArgCount;
if (!checkFunctionOrMethodParameterIndex(S, D, AL, 1, AL.getArgAsExpr(0),
@@ -4556,9 +4544,9 @@
isValidSubjectOfNSAttribute(S, QT);
}
-static void handleNSConsumedAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleNSConsumedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
S.AddNSConsumedAttr(AL.getRange(), D, AL.getAttributeSpellingListIndex(),
- AL.getKind() == AttributeList::AT_NSConsumed,
+ AL.getKind() == ParsedAttr::AT_NSConsumed,
/*template instantiation*/ false);
}
@@ -4605,13 +4593,13 @@
}
static void handleNSReturnsRetainedAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
QualType ReturnType;
if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
ReturnType = MD->getReturnType();
else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) &&
- (AL.getKind() == AttributeList::AT_NSReturnsRetained))
+ (AL.getKind() == ParsedAttr::AT_NSReturnsRetained))
return; // ignore: was handled as a type attribute
else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D))
ReturnType = PD->getType();
@@ -4631,14 +4619,14 @@
AttributeDeclKind ExpectedDeclKind;
switch (AL.getKind()) {
default: llvm_unreachable("invalid ownership attribute");
- case AttributeList::AT_NSReturnsRetained:
- case AttributeList::AT_NSReturnsAutoreleased:
- case AttributeList::AT_NSReturnsNotRetained:
+ case ParsedAttr::AT_NSReturnsRetained:
+ case ParsedAttr::AT_NSReturnsAutoreleased:
+ case ParsedAttr::AT_NSReturnsNotRetained:
ExpectedDeclKind = ExpectedFunctionOrMethod;
break;
- case AttributeList::AT_CFReturnsRetained:
- case AttributeList::AT_CFReturnsNotRetained:
+ case ParsedAttr::AT_CFReturnsRetained:
+ case ParsedAttr::AT_CFReturnsNotRetained:
ExpectedDeclKind = ExpectedFunctionMethodOrParameter;
break;
}
@@ -4651,19 +4639,19 @@
bool Cf;
switch (AL.getKind()) {
default: llvm_unreachable("invalid ownership attribute");
- case AttributeList::AT_NSReturnsRetained:
+ case ParsedAttr::AT_NSReturnsRetained:
TypeOK = isValidSubjectOfNSReturnsRetainedAttribute(ReturnType);
Cf = false;
break;
-
- case AttributeList::AT_NSReturnsAutoreleased:
- case AttributeList::AT_NSReturnsNotRetained:
+
+ case ParsedAttr::AT_NSReturnsAutoreleased:
+ case ParsedAttr::AT_NSReturnsNotRetained:
TypeOK = isValidSubjectOfNSAttribute(S, ReturnType);
Cf = false;
break;
- case AttributeList::AT_CFReturnsRetained:
- case AttributeList::AT_CFReturnsNotRetained:
+ case ParsedAttr::AT_CFReturnsRetained:
+ case ParsedAttr::AT_CFReturnsNotRetained:
TypeOK = isValidSubjectOfCFAttribute(S, ReturnType);
Cf = true;
break;
@@ -4698,23 +4686,23 @@
switch (AL.getKind()) {
default:
llvm_unreachable("invalid ownership attribute");
- case AttributeList::AT_NSReturnsAutoreleased:
+ case ParsedAttr::AT_NSReturnsAutoreleased:
D->addAttr(::new (S.Context) NSReturnsAutoreleasedAttr(
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_CFReturnsNotRetained:
+ case ParsedAttr::AT_CFReturnsNotRetained:
D->addAttr(::new (S.Context) CFReturnsNotRetainedAttr(
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_NSReturnsNotRetained:
+ case ParsedAttr::AT_NSReturnsNotRetained:
D->addAttr(::new (S.Context) NSReturnsNotRetainedAttr(
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_CFReturnsRetained:
+ case ParsedAttr::AT_CFReturnsRetained:
D->addAttr(::new (S.Context) CFReturnsRetainedAttr(
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
return;
- case AttributeList::AT_NSReturnsRetained:
+ case ParsedAttr::AT_NSReturnsRetained:
D->addAttr(::new (S.Context) NSReturnsRetainedAttr(
AL.getRange(), S.Context, AL.getAttributeSpellingListIndex()));
return;
@@ -4722,7 +4710,7 @@
}
static void handleObjCReturnsInnerPointerAttr(Sema &S, Decl *D,
- const AttributeList &Attrs) {
+ const ParsedAttr &Attrs) {
const int EP_ObjCMethod = 1;
const int EP_ObjCProperty = 2;
@@ -4750,7 +4738,7 @@
}
static void handleObjCRequiresSuperAttr(Sema &S, Decl *D,
- const AttributeList &Attrs) {
+ const ParsedAttr &Attrs) {
const auto *Method = cast<ObjCMethodDecl>(D);
const DeclContext *DC = Method->getDeclContext();
@@ -4770,7 +4758,7 @@
Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
}
-static void handleObjCBridgeAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleObjCBridgeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr;
if (!Parm) {
@@ -4800,7 +4788,7 @@
}
static void handleObjCBridgeMutableAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
IdentifierLoc *Parm = AL.isArgIdent(0) ? AL.getArgAsIdent(0) : nullptr;
if (!Parm) {
@@ -4814,7 +4802,7 @@
}
static void handleObjCBridgeRelatedAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
IdentifierInfo *RelatedClass =
AL.isArgIdent(0) ? AL.getArgAsIdent(0)->Ident : nullptr;
if (!RelatedClass) {
@@ -4832,7 +4820,7 @@
}
static void handleObjCDesignatedInitializer(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
ObjCInterfaceDecl *IFace;
if (auto *CatDecl = dyn_cast<ObjCCategoryDecl>(D->getDeclContext()))
IFace = CatDecl->getClassInterface();
@@ -4848,8 +4836,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleObjCRuntimeName(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleObjCRuntimeName(Sema &S, Decl *D, const ParsedAttr &AL) {
StringRef MetaDataName;
if (!S.checkStringLiteralArgumentAttr(AL, 0, MetaDataName))
return;
@@ -4863,7 +4850,7 @@
// but they don't have access to the declaration (legacy/third-party code)
// then they can 'enable' this feature with a typedef:
// typedef struct __attribute((objc_boxable)) legacy_struct legacy_struct;
-static void handleObjCBoxable(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleObjCBoxable(Sema &S, Decl *D, const ParsedAttr &AL) {
bool notify = false;
auto *RD = dyn_cast<RecordDecl>(D);
@@ -4886,8 +4873,7 @@
}
}
-static void handleObjCOwnershipAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleObjCOwnershipAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (hasDeclarator(D)) return;
S.Diag(D->getLocStart(), diag::err_attribute_wrong_decl_type)
@@ -4895,7 +4881,7 @@
}
static void handleObjCPreciseLifetimeAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
const auto *VD = cast<ValueDecl>(D);
QualType QT = VD->getType();
@@ -4952,7 +4938,7 @@
return ::new (Context) UuidAttr(Range, Context, Uuid, AttrSpellingListIndex);
}
-static void handleUuidAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleUuidAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!S.LangOpts.CPlusPlus) {
S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
<< AL.getName() << AttributeLangSupport::C;
@@ -5002,7 +4988,7 @@
D->addAttr(UA);
}
-static void handleMSInheritanceAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleMSInheritanceAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!S.LangOpts.CPlusPlus) {
S.Diag(AL.getLoc(), diag::err_attribute_not_supported_in_lang)
<< AL.getName() << AttributeLangSupport::C;
@@ -5018,8 +5004,7 @@
}
}
-static void handleDeclspecThreadAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleDeclspecThreadAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
const auto *VD = cast<VarDecl>(D);
if (!S.Context.getTargetInfo().isTLSSupported()) {
S.Diag(AL.getLoc(), diag::err_thread_unsupported);
@@ -5037,7 +5022,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleAbiTagAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleAbiTagAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
SmallVector<StringRef, 4> Tags;
for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {
StringRef Tag;
@@ -5069,8 +5054,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleARMInterruptAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleARMInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Check the attribute arguments.
if (AL.getNumArgs() > 1) {
S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments)
@@ -5098,8 +5082,7 @@
ARMInterruptAttr(AL.getLoc(), S.Context, Kind, Index));
}
-static void handleMSP430InterruptAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleMSP430InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeNumArgs(S, AL, 1))
return;
@@ -5134,8 +5117,7 @@
D->addAttr(UsedAttr::CreateImplicit(S.Context));
}
-static void handleMipsInterruptAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleMipsInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Only one optional argument permitted.
if (AL.getNumArgs() > 1) {
S.Diag(AL.getLoc(), diag::err_attribute_too_many_arguments)
@@ -5193,8 +5175,7 @@
AL.getLoc(), S.Context, Kind, AL.getAttributeSpellingListIndex()));
}
-static void handleAnyX86InterruptAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Semantic checks for a function with the 'interrupt' attribute.
// a) Must be a function.
// b) Must have the 'void' return type.
@@ -5259,7 +5240,7 @@
D->addAttr(UsedAttr::CreateImplicit(S.Context));
}
-static void handleAVRInterruptAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleAVRInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!isFunctionOrMethod(D)) {
S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
<< "'interrupt'" << ExpectedFunction;
@@ -5272,7 +5253,7 @@
handleSimpleAttribute<AVRInterruptAttr>(S, D, AL);
}
-static void handleAVRSignalAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleAVRSignalAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!isFunctionOrMethod(D)) {
S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
<< "'signal'" << ExpectedFunction;
@@ -5285,7 +5266,7 @@
handleSimpleAttribute<AVRSignalAttr>(S, D, AL);
}
-static void handleInterruptAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// Dispatch the interrupt attribute based on the current target.
switch (S.Context.getTargetInfo().getTriple().getArch()) {
case llvm::Triple::msp430:
@@ -5309,7 +5290,7 @@
}
static void handleAMDGPUFlatWorkGroupSizeAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
uint32_t Min = 0;
Expr *MinExpr = AL.getArgAsExpr(0);
if (!checkUInt32Argument(S, AL, MinExpr, Min))
@@ -5336,8 +5317,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleAMDGPUWavesPerEUAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAMDGPUWavesPerEUAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t Min = 0;
Expr *MinExpr = AL.getArgAsExpr(0);
if (!checkUInt32Argument(S, AL, MinExpr, Min))
@@ -5366,8 +5346,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleAMDGPUNumSGPRAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAMDGPUNumSGPRAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t NumSGPR = 0;
Expr *NumSGPRExpr = AL.getArgAsExpr(0);
if (!checkUInt32Argument(S, AL, NumSGPRExpr, NumSGPR))
@@ -5378,8 +5357,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleAMDGPUNumVGPRAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAMDGPUNumVGPRAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t NumVGPR = 0;
Expr *NumVGPRExpr = AL.getArgAsExpr(0);
if (!checkUInt32Argument(S, AL, NumVGPRExpr, NumVGPR))
@@ -5391,7 +5369,7 @@
}
static void handleX86ForceAlignArgPointerAttr(Sema &S, Decl *D,
- const AttributeList& AL) {
+ const ParsedAttr &AL) {
// If we try to apply it to a function pointer, don't warn, but don't
// do anything, either. It doesn't matter anyway, because there's nothing
// special about calling a force_align_arg_pointer function.
@@ -5415,7 +5393,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleLayoutVersion(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleLayoutVersion(Sema &S, Decl *D, const ParsedAttr &AL) {
uint32_t Version;
Expr *VersionExpr = static_cast<Expr *>(AL.getArgAsExpr(0));
if (!checkUInt32Argument(S, AL, AL.getArgAsExpr(0), Version))
@@ -5459,7 +5437,7 @@
return ::new (Context) DLLExportAttr(Range, Context, AttrSpellingListIndex);
}
-static void handleDLLAttr(Sema &S, Decl *D, const AttributeList &A) {
+static void handleDLLAttr(Sema &S, Decl *D, const ParsedAttr &A) {
if (isa<ClassTemplatePartialSpecializationDecl>(D) &&
S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored)
@@ -5468,7 +5446,7 @@
}
if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
- if (FD->isInlined() && A.getKind() == AttributeList::AT_DLLImport &&
+ if (FD->isInlined() && A.getKind() == ParsedAttr::AT_DLLImport &&
!S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
// MinGW doesn't allow dllimport on inline functions.
S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored_on_inline)
@@ -5486,7 +5464,7 @@
}
unsigned Index = A.getAttributeSpellingListIndex();
- Attr *NewAttr = A.getKind() == AttributeList::AT_DLLExport
+ Attr *NewAttr = A.getKind() == ParsedAttr::AT_DLLExport
? (Attr *)S.mergeDLLExportAttr(D, A.getRange(), Index)
: (Attr *)S.mergeDLLImportAttr(D, A.getRange(), Index);
if (NewAttr)
@@ -5529,7 +5507,7 @@
MSInheritanceAttr(Range, Context, BestCase, AttrSpellingListIndex);
}
-static void handleCapabilityAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
// The capability attributes take a single string parameter for the name of
// the capability they represent. The lockable attribute does not take any
// parameters. However, semantically, both attributes represent the same
@@ -5540,7 +5518,7 @@
// literal will be considered a "mutex."
StringRef N("mutex");
SourceLocation LiteralLoc;
- if (AL.getKind() == AttributeList::AT_Capability &&
+ if (AL.getKind() == ParsedAttr::AT_Capability &&
!S.checkStringLiteralArgumentAttr(AL, 0, N, &LiteralLoc))
return;
@@ -5553,8 +5531,7 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleAssertCapabilityAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleAssertCapabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
SmallVector<Expr*, 1> Args;
if (!checkLockFunAttrCommon(S, D, AL, Args))
return;
@@ -5565,7 +5542,7 @@
}
static void handleAcquireCapabilityAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
SmallVector<Expr*, 1> Args;
if (!checkLockFunAttrCommon(S, D, AL, Args))
return;
@@ -5577,7 +5554,7 @@
}
static void handleTryAcquireCapabilityAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
SmallVector<Expr*, 2> Args;
if (!checkTryLockFunAttrCommon(S, D, AL, Args))
return;
@@ -5591,7 +5568,7 @@
}
static void handleReleaseCapabilityAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
// Check that all arguments are lockable objects.
SmallVector<Expr *, 1> Args;
checkAttrArgsAreCapabilityObjs(S, D, AL, Args, 0, true);
@@ -5602,7 +5579,7 @@
}
static void handleRequiresCapabilityAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
return;
@@ -5619,7 +5596,7 @@
D->addAttr(RCA);
}
-static void handleDeprecatedAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleDeprecatedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (const auto *NSD = dyn_cast<NamespaceDecl>(D)) {
if (NSD->isAnonymousNamespace()) {
S.Diag(AL.getLoc(), diag::warn_deprecated_anonymous_namespace);
@@ -5659,7 +5636,7 @@
return false;
}
-static void handleNoSanitizeAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleNoSanitizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (!checkAttributeAtLeastNumArgs(S, AL, 1))
return;
@@ -5686,7 +5663,7 @@
}
static void handleNoSanitizeSpecificAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
StringRef AttrName = AL.getName()->getName();
normalizeName(AttrName);
StringRef SanitizerName = llvm::StringSwitch<StringRef>(AttrName)
@@ -5702,15 +5679,14 @@
AL.getAttributeSpellingListIndex()));
}
-static void handleInternalLinkageAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleInternalLinkageAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (InternalLinkageAttr *Internal =
S.mergeInternalLinkageAttr(D, AL.getRange(), AL.getName(),
AL.getAttributeSpellingListIndex()))
D->addAttr(Internal);
}
-static void handleOpenCLNoSVMAttr(Sema &S, Decl *D, const AttributeList &AL) {
+static void handleOpenCLNoSVMAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (S.LangOpts.OpenCLVersion != 200)
S.Diag(AL.getLoc(), diag::err_attribute_requires_opencl_version)
<< AL.getName() << "2.0" << 0;
@@ -5723,13 +5699,13 @@
/// such as checking whether a parameter was properly specified, or the correct
/// number of arguments were passed, etc.
static bool handleCommonAttributeFeatures(Sema &S, Decl *D,
- const AttributeList &AL) {
+ const ParsedAttr &AL) {
// Several attributes carry different semantics than the parsing requires, so
// those are opted out of the common argument checks.
//
// We also bail on unknown and ignored attributes because those are handled
// as part of the target-specific handling logic.
- if (AL.getKind() == AttributeList::UnknownAttribute)
+ if (AL.getKind() == ParsedAttr::UnknownAttribute)
return false;
// Check whether the attribute requires specific language extensions to be
// enabled.
@@ -5762,8 +5738,7 @@
return false;
}
-static void handleOpenCLAccessAttr(Sema &S, Decl *D,
- const AttributeList &AL) {
+static void handleOpenCLAccessAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
if (D->isInvalidDecl())
return;
@@ -5804,9 +5779,9 @@
/// the attribute applies to decls. If the attribute is a type attribute, just
/// silently ignore it if a GNU attribute.
static void ProcessDeclAttribute(Sema &S, Scope *scope, Decl *D,
- const AttributeList &AL,
+ const ParsedAttr &AL,
bool IncludeCXX11Attributes) {
- if (AL.isInvalid() || AL.getKind() == AttributeList::IgnoredAttribute)
+ if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
return;
// Ignore C++11 attributes on declarator chunks: they appertain to the type
@@ -5817,7 +5792,7 @@
// Unknown attributes are automatically warned on. Target-specific attributes
// which do not apply to the current target architecture are treated as
// though they were unknown attributes.
- if (AL.getKind() == AttributeList::UnknownAttribute ||
+ if (AL.getKind() == ParsedAttr::UnknownAttribute ||
!AL.existsInTarget(S.Context.getTargetInfo())) {
S.Diag(AL.getLoc(), AL.isDeclspecAttribute()
? diag::warn_unhandled_ms_attribute_ignored
@@ -5839,616 +5814,616 @@
S.Diag(AL.getLoc(), diag::err_stmt_attribute_invalid_on_decl)
<< AL.getName() << D->getLocation();
break;
- case AttributeList::AT_Interrupt:
+ case ParsedAttr::AT_Interrupt:
handleInterruptAttr(S, D, AL);
break;
- case AttributeList::AT_X86ForceAlignArgPointer:
+ case ParsedAttr::AT_X86ForceAlignArgPointer:
handleX86ForceAlignArgPointerAttr(S, D, AL);
break;
- case AttributeList::AT_DLLExport:
- case AttributeList::AT_DLLImport:
+ case ParsedAttr::AT_DLLExport:
+ case ParsedAttr::AT_DLLImport:
handleDLLAttr(S, D, AL);
break;
- case AttributeList::AT_Mips16:
+ case ParsedAttr::AT_Mips16:
handleSimpleAttributeWithExclusions<Mips16Attr, MicroMipsAttr,
MipsInterruptAttr>(S, D, AL);
break;
- case AttributeList::AT_NoMips16:
+ case ParsedAttr::AT_NoMips16:
handleSimpleAttribute<NoMips16Attr>(S, D, AL);
break;
- case AttributeList::AT_MicroMips:
+ case ParsedAttr::AT_MicroMips:
handleSimpleAttributeWithExclusions<MicroMipsAttr, Mips16Attr>(S, D, AL);
break;
- case AttributeList::AT_NoMicroMips:
+ case ParsedAttr::AT_NoMicroMips:
handleSimpleAttribute<NoMicroMipsAttr>(S, D, AL);
break;
- case AttributeList::AT_MipsLongCall:
+ case ParsedAttr::AT_MipsLongCall:
handleSimpleAttributeWithExclusions<MipsLongCallAttr, MipsShortCallAttr>(
S, D, AL);
break;
- case AttributeList::AT_MipsShortCall:
+ case ParsedAttr::AT_MipsShortCall:
handleSimpleAttributeWithExclusions<MipsShortCallAttr, MipsLongCallAttr>(
S, D, AL);
break;
- case AttributeList::AT_AMDGPUFlatWorkGroupSize:
+ case ParsedAttr::AT_AMDGPUFlatWorkGroupSize:
handleAMDGPUFlatWorkGroupSizeAttr(S, D, AL);
break;
- case AttributeList::AT_AMDGPUWavesPerEU:
+ case ParsedAttr::AT_AMDGPUWavesPerEU:
handleAMDGPUWavesPerEUAttr(S, D, AL);
break;
- case AttributeList::AT_AMDGPUNumSGPR:
+ case ParsedAttr::AT_AMDGPUNumSGPR:
handleAMDGPUNumSGPRAttr(S, D, AL);
break;
- case AttributeList::AT_AMDGPUNumVGPR:
+ case ParsedAttr::AT_AMDGPUNumVGPR:
handleAMDGPUNumVGPRAttr(S, D, AL);
break;
- case AttributeList::AT_AVRSignal:
+ case ParsedAttr::AT_AVRSignal:
handleAVRSignalAttr(S, D, AL);
break;
- case AttributeList::AT_IBAction:
+ case ParsedAttr::AT_IBAction:
handleSimpleAttribute<IBActionAttr>(S, D, AL);
break;
- case AttributeList::AT_IBOutlet:
+ case ParsedAttr::AT_IBOutlet:
handleIBOutlet(S, D, AL);
break;
- case AttributeList::AT_IBOutletCollection:
+ case ParsedAttr::AT_IBOutletCollection:
handleIBOutletCollection(S, D, AL);
break;
- case AttributeList::AT_IFunc:
+ case ParsedAttr::AT_IFunc:
handleIFuncAttr(S, D, AL);
break;
- case AttributeList::AT_Alias:
+ case ParsedAttr::AT_Alias:
handleAliasAttr(S, D, AL);
break;
- case AttributeList::AT_Aligned:
+ case ParsedAttr::AT_Aligned:
handleAlignedAttr(S, D, AL);
break;
- case AttributeList::AT_AlignValue:
+ case ParsedAttr::AT_AlignValue:
handleAlignValueAttr(S, D, AL);
break;
- case AttributeList::AT_AllocSize:
+ case ParsedAttr::AT_AllocSize:
handleAllocSizeAttr(S, D, AL);
break;
- case AttributeList::AT_AlwaysInline:
+ case ParsedAttr::AT_AlwaysInline:
handleAlwaysInlineAttr(S, D, AL);
break;
- case AttributeList::AT_Artificial:
+ case ParsedAttr::AT_Artificial:
handleSimpleAttribute<ArtificialAttr>(S, D, AL);
break;
- case AttributeList::AT_AnalyzerNoReturn:
+ case ParsedAttr::AT_AnalyzerNoReturn:
handleAnalyzerNoReturnAttr(S, D, AL);
break;
- case AttributeList::AT_TLSModel:
+ case ParsedAttr::AT_TLSModel:
handleTLSModelAttr(S, D, AL);
break;
- case AttributeList::AT_Annotate:
+ case ParsedAttr::AT_Annotate:
handleAnnotateAttr(S, D, AL);
break;
- case AttributeList::AT_Availability:
+ case ParsedAttr::AT_Availability:
handleAvailabilityAttr(S, D, AL);
break;
- case AttributeList::AT_CarriesDependency:
+ case ParsedAttr::AT_CarriesDependency:
handleDependencyAttr(S, scope, D, AL);
break;
- case AttributeList::AT_Common:
+ case ParsedAttr::AT_Common:
handleCommonAttr(S, D, AL);
break;
- case AttributeList::AT_CUDAConstant:
+ case ParsedAttr::AT_CUDAConstant:
handleConstantAttr(S, D, AL);
break;
- case AttributeList::AT_PassObjectSize:
+ case ParsedAttr::AT_PassObjectSize:
handlePassObjectSizeAttr(S, D, AL);
break;
- case AttributeList::AT_Constructor:
+ case ParsedAttr::AT_Constructor:
handleConstructorAttr(S, D, AL);
break;
- case AttributeList::AT_CXX11NoReturn:
+ case ParsedAttr::AT_CXX11NoReturn:
handleSimpleAttribute<CXX11NoReturnAttr>(S, D, AL);
break;
- case AttributeList::AT_Deprecated:
+ case ParsedAttr::AT_Deprecated:
handleDeprecatedAttr(S, D, AL);
break;
- case AttributeList::AT_Destructor:
+ case ParsedAttr::AT_Destructor:
handleDestructorAttr(S, D, AL);
break;
- case AttributeList::AT_EnableIf:
+ case ParsedAttr::AT_EnableIf:
handleEnableIfAttr(S, D, AL);
break;
- case AttributeList::AT_DiagnoseIf:
+ case ParsedAttr::AT_DiagnoseIf:
handleDiagnoseIfAttr(S, D, AL);
break;
- case AttributeList::AT_ExtVectorType:
+ case ParsedAttr::AT_ExtVectorType:
handleExtVectorTypeAttr(S, D, AL);
break;
- case AttributeList::AT_ExternalSourceSymbol:
+ case ParsedAttr::AT_ExternalSourceSymbol:
handleExternalSourceSymbolAttr(S, D, AL);
break;
- case AttributeList::AT_MinSize:
+ case ParsedAttr::AT_MinSize:
handleMinSizeAttr(S, D, AL);
break;
- case AttributeList::AT_OptimizeNone:
+ case ParsedAttr::AT_OptimizeNone:
handleOptimizeNoneAttr(S, D, AL);
break;
- case AttributeList::AT_FlagEnum:
+ case ParsedAttr::AT_FlagEnum:
handleSimpleAttribute<FlagEnumAttr>(S, D, AL);
break;
- case AttributeList::AT_EnumExtensibility:
+ case ParsedAttr::AT_EnumExtensibility:
handleEnumExtensibilityAttr(S, D, AL);
break;
- case AttributeList::AT_Flatten:
+ case ParsedAttr::AT_Flatten:
handleSimpleAttribute<FlattenAttr>(S, D, AL);
break;
- case AttributeList::AT_Format:
+ case ParsedAttr::AT_Format:
handleFormatAttr(S, D, AL);
break;
- case AttributeList::AT_FormatArg:
+ case ParsedAttr::AT_FormatArg:
handleFormatArgAttr(S, D, AL);
break;
- case AttributeList::AT_CUDAGlobal:
+ case ParsedAttr::AT_CUDAGlobal:
handleGlobalAttr(S, D, AL);
break;
- case AttributeList::AT_CUDADevice:
+ case ParsedAttr::AT_CUDADevice:
handleSimpleAttributeWithExclusions<CUDADeviceAttr, CUDAGlobalAttr>(S, D,
AL);
break;
- case AttributeList::AT_CUDAHost:
+ case ParsedAttr::AT_CUDAHost:
handleSimpleAttributeWithExclusions<CUDAHostAttr, CUDAGlobalAttr>(S, D, AL);
break;
- case AttributeList::AT_GNUInline:
+ case ParsedAttr::AT_GNUInline:
handleGNUInlineAttr(S, D, AL);
break;
- case AttributeList::AT_CUDALaunchBounds:
+ case ParsedAttr::AT_CUDALaunchBounds:
handleLaunchBoundsAttr(S, D, AL);
break;
- case AttributeList::AT_Restrict:
+ case ParsedAttr::AT_Restrict:
handleRestrictAttr(S, D, AL);
break;
- case AttributeList::AT_MayAlias:
+ case ParsedAttr::AT_MayAlias:
handleSimpleAttribute<MayAliasAttr>(S, D, AL);
break;
- case AttributeList::AT_Mode:
+ case ParsedAttr::AT_Mode:
handleModeAttr(S, D, AL);
break;
- case AttributeList::AT_NoAlias:
+ case ParsedAttr::AT_NoAlias:
handleSimpleAttribute<NoAliasAttr>(S, D, AL);
break;
- case AttributeList::AT_NoCommon:
+ case ParsedAttr::AT_NoCommon:
handleSimpleAttribute<NoCommonAttr>(S, D, AL);
break;
- case AttributeList::AT_NoSplitStack:
+ case ParsedAttr::AT_NoSplitStack:
handleSimpleAttribute<NoSplitStackAttr>(S, D, AL);
break;
- case AttributeList::AT_NonNull:
+ case ParsedAttr::AT_NonNull:
if (auto *PVD = dyn_cast<ParmVarDecl>(D))
handleNonNullAttrParameter(S, PVD, AL);
else
handleNonNullAttr(S, D, AL);
break;
- case AttributeList::AT_ReturnsNonNull:
+ case ParsedAttr::AT_ReturnsNonNull:
handleReturnsNonNullAttr(S, D, AL);
break;
- case AttributeList::AT_NoEscape:
+ case ParsedAttr::AT_NoEscape:
handleNoEscapeAttr(S, D, AL);
break;
- case AttributeList::AT_AssumeAligned:
+ case ParsedAttr::AT_AssumeAligned:
handleAssumeAlignedAttr(S, D, AL);
break;
- case AttributeList::AT_AllocAlign:
+ case ParsedAttr::AT_AllocAlign:
handleAllocAlignAttr(S, D, AL);
break;
- case AttributeList::AT_Overloadable:
+ case ParsedAttr::AT_Overloadable:
handleSimpleAttribute<OverloadableAttr>(S, D, AL);
break;
- case AttributeList::AT_Ownership:
+ case ParsedAttr::AT_Ownership:
handleOwnershipAttr(S, D, AL);
break;
- case AttributeList::AT_Cold:
+ case ParsedAttr::AT_Cold:
handleSimpleAttributeWithExclusions<ColdAttr, HotAttr>(S, D, AL);
break;
- case AttributeList::AT_Hot:
+ case ParsedAttr::AT_Hot:
handleSimpleAttributeWithExclusions<HotAttr, ColdAttr>(S, D, AL);
break;
- case AttributeList::AT_Naked:
+ case ParsedAttr::AT_Naked:
handleNakedAttr(S, D, AL);
break;
- case AttributeList::AT_NoReturn:
+ case ParsedAttr::AT_NoReturn:
handleNoReturnAttr(S, D, AL);
break;
- case AttributeList::AT_AnyX86NoCfCheck:
+ case ParsedAttr::AT_AnyX86NoCfCheck:
handleNoCfCheckAttr(S, D, AL);
break;
- case AttributeList::AT_NoThrow:
+ case ParsedAttr::AT_NoThrow:
handleSimpleAttribute<NoThrowAttr>(S, D, AL);
break;
- case AttributeList::AT_CUDAShared:
+ case ParsedAttr::AT_CUDAShared:
handleSharedAttr(S, D, AL);
break;
- case AttributeList::AT_VecReturn:
+ case ParsedAttr::AT_VecReturn:
handleVecReturnAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCOwnership:
+ case ParsedAttr::AT_ObjCOwnership:
handleObjCOwnershipAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCPreciseLifetime:
+ case ParsedAttr::AT_ObjCPreciseLifetime:
handleObjCPreciseLifetimeAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCReturnsInnerPointer:
+ case ParsedAttr::AT_ObjCReturnsInnerPointer:
handleObjCReturnsInnerPointerAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCRequiresSuper:
+ case ParsedAttr::AT_ObjCRequiresSuper:
handleObjCRequiresSuperAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCBridge:
+ case ParsedAttr::AT_ObjCBridge:
handleObjCBridgeAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCBridgeMutable:
+ case ParsedAttr::AT_ObjCBridgeMutable:
handleObjCBridgeMutableAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCBridgeRelated:
+ case ParsedAttr::AT_ObjCBridgeRelated:
handleObjCBridgeRelatedAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCDesignatedInitializer:
+ case ParsedAttr::AT_ObjCDesignatedInitializer:
handleObjCDesignatedInitializer(S, D, AL);
break;
- case AttributeList::AT_ObjCRuntimeName:
+ case ParsedAttr::AT_ObjCRuntimeName:
handleObjCRuntimeName(S, D, AL);
break;
- case AttributeList::AT_ObjCRuntimeVisible:
- handleSimpleAttribute<ObjCRuntimeVisibleAttr>(S, D, AL);
- break;
- case AttributeList::AT_ObjCBoxable:
+ case ParsedAttr::AT_ObjCRuntimeVisible:
+ handleSimpleAttribute<ObjCRuntimeVisibleAttr>(S, D, AL);
+ break;
+ case ParsedAttr::AT_ObjCBoxable:
handleObjCBoxable(S, D, AL);
break;
- case AttributeList::AT_CFAuditedTransfer:
+ case ParsedAttr::AT_CFAuditedTransfer:
handleSimpleAttributeWithExclusions<CFAuditedTransferAttr,
CFUnknownTransferAttr>(S, D, AL);
break;
- case AttributeList::AT_CFUnknownTransfer:
+ case ParsedAttr::AT_CFUnknownTransfer:
handleSimpleAttributeWithExclusions<CFUnknownTransferAttr,
CFAuditedTransferAttr>(S, D, AL);
break;
- case AttributeList::AT_CFConsumed:
- case AttributeList::AT_NSConsumed:
+ case ParsedAttr::AT_CFConsumed:
+ case ParsedAttr::AT_NSConsumed:
handleNSConsumedAttr(S, D, AL);
break;
- case AttributeList::AT_NSConsumesSelf:
+ case ParsedAttr::AT_NSConsumesSelf:
handleSimpleAttribute<NSConsumesSelfAttr>(S, D, AL);
break;
- case AttributeList::AT_NSReturnsAutoreleased:
- case AttributeList::AT_NSReturnsNotRetained:
- case AttributeList::AT_CFReturnsNotRetained:
- case AttributeList::AT_NSReturnsRetained:
- case AttributeList::AT_CFReturnsRetained:
+ case ParsedAttr::AT_NSReturnsAutoreleased:
+ case ParsedAttr::AT_NSReturnsNotRetained:
+ case ParsedAttr::AT_CFReturnsNotRetained:
+ case ParsedAttr::AT_NSReturnsRetained:
+ case ParsedAttr::AT_CFReturnsRetained:
handleNSReturnsRetainedAttr(S, D, AL);
break;
- case AttributeList::AT_WorkGroupSizeHint:
+ case ParsedAttr::AT_WorkGroupSizeHint:
handleWorkGroupSize<WorkGroupSizeHintAttr>(S, D, AL);
break;
- case AttributeList::AT_ReqdWorkGroupSize:
+ case ParsedAttr::AT_ReqdWorkGroupSize:
handleWorkGroupSize<ReqdWorkGroupSizeAttr>(S, D, AL);
break;
- case AttributeList::AT_OpenCLIntelReqdSubGroupSize:
+ case ParsedAttr::AT_OpenCLIntelReqdSubGroupSize:
handleSubGroupSize(S, D, AL);
break;
- case AttributeList::AT_VecTypeHint:
+ case ParsedAttr::AT_VecTypeHint:
handleVecTypeHint(S, D, AL);
break;
- case AttributeList::AT_RequireConstantInit:
+ case ParsedAttr::AT_RequireConstantInit:
handleSimpleAttribute<RequireConstantInitAttr>(S, D, AL);
break;
- case AttributeList::AT_InitPriority:
+ case ParsedAttr::AT_InitPriority:
handleInitPriorityAttr(S, D, AL);
break;
- case AttributeList::AT_Packed:
+ case ParsedAttr::AT_Packed:
handlePackedAttr(S, D, AL);
break;
- case AttributeList::AT_Section:
+ case ParsedAttr::AT_Section:
handleSectionAttr(S, D, AL);
break;
- case AttributeList::AT_Target:
+ case ParsedAttr::AT_Target:
handleTargetAttr(S, D, AL);
break;
- case AttributeList::AT_MinVectorWidth:
+ case ParsedAttr::AT_MinVectorWidth:
handleMinVectorWidthAttr(S, D, AL);
break;
- case AttributeList::AT_Unavailable:
+ case ParsedAttr::AT_Unavailable:
handleAttrWithMessage<UnavailableAttr>(S, D, AL);
break;
- case AttributeList::AT_ArcWeakrefUnavailable:
+ case ParsedAttr::AT_ArcWeakrefUnavailable:
handleSimpleAttribute<ArcWeakrefUnavailableAttr>(S, D, AL);
break;
- case AttributeList::AT_ObjCRootClass:
+ case ParsedAttr::AT_ObjCRootClass:
handleSimpleAttribute<ObjCRootClassAttr>(S, D, AL);
break;
- case AttributeList::AT_ObjCSubclassingRestricted:
+ case ParsedAttr::AT_ObjCSubclassingRestricted:
handleSimpleAttribute<ObjCSubclassingRestrictedAttr>(S, D, AL);
break;
- case AttributeList::AT_ObjCExplicitProtocolImpl:
+ case ParsedAttr::AT_ObjCExplicitProtocolImpl:
handleObjCSuppresProtocolAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCRequiresPropertyDefs:
+ case ParsedAttr::AT_ObjCRequiresPropertyDefs:
handleSimpleAttribute<ObjCRequiresPropertyDefsAttr>(S, D, AL);
break;
- case AttributeList::AT_Unused:
+ case ParsedAttr::AT_Unused:
handleUnusedAttr(S, D, AL);
break;
- case AttributeList::AT_ReturnsTwice:
+ case ParsedAttr::AT_ReturnsTwice:
handleSimpleAttribute<ReturnsTwiceAttr>(S, D, AL);
break;
- case AttributeList::AT_NotTailCalled:
+ case ParsedAttr::AT_NotTailCalled:
handleSimpleAttributeWithExclusions<NotTailCalledAttr, AlwaysInlineAttr>(
S, D, AL);
break;
- case AttributeList::AT_DisableTailCalls:
+ case ParsedAttr::AT_DisableTailCalls:
handleSimpleAttributeWithExclusions<DisableTailCallsAttr, NakedAttr>(S, D,
AL);
break;
- case AttributeList::AT_Used:
+ case ParsedAttr::AT_Used:
handleSimpleAttribute<UsedAttr>(S, D, AL);
break;
- case AttributeList::AT_Visibility:
+ case ParsedAttr::AT_Visibility:
handleVisibilityAttr(S, D, AL, false);
break;
- case AttributeList::AT_TypeVisibility:
+ case ParsedAttr::AT_TypeVisibility:
handleVisibilityAttr(S, D, AL, true);
break;
- case AttributeList::AT_WarnUnused:
+ case ParsedAttr::AT_WarnUnused:
handleSimpleAttribute<WarnUnusedAttr>(S, D, AL);
break;
- case AttributeList::AT_WarnUnusedResult:
+ case ParsedAttr::AT_WarnUnusedResult:
handleWarnUnusedResult(S, D, AL);
break;
- case AttributeList::AT_Weak:
+ case ParsedAttr::AT_Weak:
handleSimpleAttribute<WeakAttr>(S, D, AL);
break;
- case AttributeList::AT_WeakRef:
+ case ParsedAttr::AT_WeakRef:
handleWeakRefAttr(S, D, AL);
break;
- case AttributeList::AT_WeakImport:
+ case ParsedAttr::AT_WeakImport:
handleWeakImportAttr(S, D, AL);
break;
- case AttributeList::AT_TransparentUnion:
+ case ParsedAttr::AT_TransparentUnion:
handleTransparentUnionAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCException:
+ case ParsedAttr::AT_ObjCException:
handleSimpleAttribute<ObjCExceptionAttr>(S, D, AL);
break;
- case AttributeList::AT_ObjCMethodFamily:
+ case ParsedAttr::AT_ObjCMethodFamily:
handleObjCMethodFamilyAttr(S, D, AL);
break;
- case AttributeList::AT_ObjCNSObject:
+ case ParsedAttr::AT_ObjCNSObject:
handleObjCNSObject(S, D, AL);
break;
- case AttributeList::AT_ObjCIndependentClass:
+ case ParsedAttr::AT_ObjCIndependentClass:
handleObjCIndependentClass(S, D, AL);
break;
- case AttributeList::AT_Blocks:
+ case ParsedAttr::AT_Blocks:
handleBlocksAttr(S, D, AL);
break;
- case AttributeList::AT_Sentinel:
+ case ParsedAttr::AT_Sentinel:
handleSentinelAttr(S, D, AL);
break;
- case AttributeList::AT_Const:
+ case ParsedAttr::AT_Const:
handleSimpleAttribute<ConstAttr>(S, D, AL);
break;
- case AttributeList::AT_Pure:
+ case ParsedAttr::AT_Pure:
handleSimpleAttribute<PureAttr>(S, D, AL);
break;
- case AttributeList::AT_Cleanup:
+ case ParsedAttr::AT_Cleanup:
handleCleanupAttr(S, D, AL);
break;
- case AttributeList::AT_NoDebug:
+ case ParsedAttr::AT_NoDebug:
handleNoDebugAttr(S, D, AL);
break;
- case AttributeList::AT_NoDuplicate:
+ case ParsedAttr::AT_NoDuplicate:
handleSimpleAttribute<NoDuplicateAttr>(S, D, AL);
break;
- case AttributeList::AT_Convergent:
+ case ParsedAttr::AT_Convergent:
handleSimpleAttribute<ConvergentAttr>(S, D, AL);
break;
- case AttributeList::AT_NoInline:
+ case ParsedAttr::AT_NoInline:
handleSimpleAttribute<NoInlineAttr>(S, D, AL);
break;
- case AttributeList::AT_NoInstrumentFunction: // Interacts with -pg.
+ case ParsedAttr::AT_NoInstrumentFunction: // Interacts with -pg.
handleSimpleAttribute<NoInstrumentFunctionAttr>(S, D, AL);
break;
- case AttributeList::AT_NoStackProtector:
+ case ParsedAttr::AT_NoStackProtector:
// Interacts with -fstack-protector options.
handleSimpleAttribute<NoStackProtectorAttr>(S, D, AL);
break;
- case AttributeList::AT_StdCall:
- case AttributeList::AT_CDecl:
- case AttributeList::AT_FastCall:
- case AttributeList::AT_ThisCall:
- case AttributeList::AT_Pascal:
- case AttributeList::AT_RegCall:
- case AttributeList::AT_SwiftCall:
- case AttributeList::AT_VectorCall:
- case AttributeList::AT_MSABI:
- case AttributeList::AT_SysVABI:
- case AttributeList::AT_Pcs:
- case AttributeList::AT_IntelOclBicc:
- case AttributeList::AT_PreserveMost:
- case AttributeList::AT_PreserveAll:
+ case ParsedAttr::AT_StdCall:
+ case ParsedAttr::AT_CDecl:
+ case ParsedAttr::AT_FastCall:
+ case ParsedAttr::AT_ThisCall:
+ case ParsedAttr::AT_Pascal:
+ case ParsedAttr::AT_RegCall:
+ case ParsedAttr::AT_SwiftCall:
+ case ParsedAttr::AT_VectorCall:
+ case ParsedAttr::AT_MSABI:
+ case ParsedAttr::AT_SysVABI:
+ case ParsedAttr::AT_Pcs:
+ case ParsedAttr::AT_IntelOclBicc:
+ case ParsedAttr::AT_PreserveMost:
+ case ParsedAttr::AT_PreserveAll:
handleCallConvAttr(S, D, AL);
break;
- case AttributeList::AT_Suppress:
+ case ParsedAttr::AT_Suppress:
handleSuppressAttr(S, D, AL);
break;
- case AttributeList::AT_OpenCLKernel:
+ case ParsedAttr::AT_OpenCLKernel:
handleSimpleAttribute<OpenCLKernelAttr>(S, D, AL);
break;
- case AttributeList::AT_OpenCLAccess:
+ case ParsedAttr::AT_OpenCLAccess:
handleOpenCLAccessAttr(S, D, AL);
break;
- case AttributeList::AT_OpenCLNoSVM:
+ case ParsedAttr::AT_OpenCLNoSVM:
handleOpenCLNoSVMAttr(S, D, AL);
break;
- case AttributeList::AT_SwiftContext:
+ case ParsedAttr::AT_SwiftContext:
handleParameterABIAttr(S, D, AL, ParameterABI::SwiftContext);
break;
- case AttributeList::AT_SwiftErrorResult:
+ case ParsedAttr::AT_SwiftErrorResult:
handleParameterABIAttr(S, D, AL, ParameterABI::SwiftErrorResult);
break;
- case AttributeList::AT_SwiftIndirectResult:
+ case ParsedAttr::AT_SwiftIndirectResult:
handleParameterABIAttr(S, D, AL, ParameterABI::SwiftIndirectResult);
break;
- case AttributeList::AT_InternalLinkage:
+ case ParsedAttr::AT_InternalLinkage:
handleInternalLinkageAttr(S, D, AL);
break;
- case AttributeList::AT_LTOVisibilityPublic:
+ case ParsedAttr::AT_LTOVisibilityPublic:
handleSimpleAttribute<LTOVisibilityPublicAttr>(S, D, AL);
break;
// Microsoft attributes:
- case AttributeList::AT_EmptyBases:
+ case ParsedAttr::AT_EmptyBases:
handleSimpleAttribute<EmptyBasesAttr>(S, D, AL);
break;
- case AttributeList::AT_LayoutVersion:
+ case ParsedAttr::AT_LayoutVersion:
handleLayoutVersion(S, D, AL);
break;
- case AttributeList::AT_TrivialABI:
+ case ParsedAttr::AT_TrivialABI:
handleSimpleAttribute<TrivialABIAttr>(S, D, AL);
break;
- case AttributeList::AT_MSNoVTable:
+ case ParsedAttr::AT_MSNoVTable:
handleSimpleAttribute<MSNoVTableAttr>(S, D, AL);
break;
- case AttributeList::AT_MSStruct:
+ case ParsedAttr::AT_MSStruct:
handleSimpleAttribute<MSStructAttr>(S, D, AL);
break;
- case AttributeList::AT_Uuid:
+ case ParsedAttr::AT_Uuid:
handleUuidAttr(S, D, AL);
break;
- case AttributeList::AT_MSInheritance:
+ case ParsedAttr::AT_MSInheritance:
handleMSInheritanceAttr(S, D, AL);
break;
- case AttributeList::AT_SelectAny:
+ case ParsedAttr::AT_SelectAny:
handleSimpleAttribute<SelectAnyAttr>(S, D, AL);
break;
- case AttributeList::AT_Thread:
+ case ParsedAttr::AT_Thread:
handleDeclspecThreadAttr(S, D, AL);
break;
- case AttributeList::AT_AbiTag:
+ case ParsedAttr::AT_AbiTag:
handleAbiTagAttr(S, D, AL);
break;
// Thread safety attributes:
- case AttributeList::AT_AssertExclusiveLock:
+ case ParsedAttr::AT_AssertExclusiveLock:
handleAssertExclusiveLockAttr(S, D, AL);
break;
- case AttributeList::AT_AssertSharedLock:
+ case ParsedAttr::AT_AssertSharedLock:
handleAssertSharedLockAttr(S, D, AL);
break;
- case AttributeList::AT_GuardedVar:
+ case ParsedAttr::AT_GuardedVar:
handleSimpleAttribute<GuardedVarAttr>(S, D, AL);
break;
- case AttributeList::AT_PtGuardedVar:
+ case ParsedAttr::AT_PtGuardedVar:
handlePtGuardedVarAttr(S, D, AL);
break;
- case AttributeList::AT_ScopedLockable:
+ case ParsedAttr::AT_ScopedLockable:
handleSimpleAttribute<ScopedLockableAttr>(S, D, AL);
break;
- case AttributeList::AT_NoSanitize:
+ case ParsedAttr::AT_NoSanitize:
handleNoSanitizeAttr(S, D, AL);
break;
- case AttributeList::AT_NoSanitizeSpecific:
+ case ParsedAttr::AT_NoSanitizeSpecific:
handleNoSanitizeSpecificAttr(S, D, AL);
break;
- case AttributeList::AT_NoThreadSafetyAnalysis:
+ case ParsedAttr::AT_NoThreadSafetyAnalysis:
handleSimpleAttribute<NoThreadSafetyAnalysisAttr>(S, D, AL);
break;
- case AttributeList::AT_GuardedBy:
+ case ParsedAttr::AT_GuardedBy:
handleGuardedByAttr(S, D, AL);
break;
- case AttributeList::AT_PtGuardedBy:
+ case ParsedAttr::AT_PtGuardedBy:
handlePtGuardedByAttr(S, D, AL);
break;
- case AttributeList::AT_ExclusiveTrylockFunction:
+ case ParsedAttr::AT_ExclusiveTrylockFunction:
handleExclusiveTrylockFunctionAttr(S, D, AL);
break;
- case AttributeList::AT_LockReturned:
+ case ParsedAttr::AT_LockReturned:
handleLockReturnedAttr(S, D, AL);
break;
- case AttributeList::AT_LocksExcluded:
+ case ParsedAttr::AT_LocksExcluded:
handleLocksExcludedAttr(S, D, AL);
break;
- case AttributeList::AT_SharedTrylockFunction:
+ case ParsedAttr::AT_SharedTrylockFunction:
handleSharedTrylockFunctionAttr(S, D, AL);
break;
- case AttributeList::AT_AcquiredBefore:
+ case ParsedAttr::AT_AcquiredBefore:
handleAcquiredBeforeAttr(S, D, AL);
break;
- case AttributeList::AT_AcquiredAfter:
+ case ParsedAttr::AT_AcquiredAfter:
handleAcquiredAfterAttr(S, D, AL);
break;
// Capability analysis attributes.
- case AttributeList::AT_Capability:
- case AttributeList::AT_Lockable:
+ case ParsedAttr::AT_Capability:
+ case ParsedAttr::AT_Lockable:
handleCapabilityAttr(S, D, AL);
break;
- case AttributeList::AT_RequiresCapability:
+ case ParsedAttr::AT_RequiresCapability:
handleRequiresCapabilityAttr(S, D, AL);
break;
- case AttributeList::AT_AssertCapability:
+ case ParsedAttr::AT_AssertCapability:
handleAssertCapabilityAttr(S, D, AL);
break;
- case AttributeList::AT_AcquireCapability:
+ case ParsedAttr::AT_AcquireCapability:
handleAcquireCapabilityAttr(S, D, AL);
break;
- case AttributeList::AT_ReleaseCapability:
+ case ParsedAttr::AT_ReleaseCapability:
handleReleaseCapabilityAttr(S, D, AL);
break;
- case AttributeList::AT_TryAcquireCapability:
+ case ParsedAttr::AT_TryAcquireCapability:
handleTryAcquireCapabilityAttr(S, D, AL);
break;
// Consumed analysis attributes.
- case AttributeList::AT_Consumable:
+ case ParsedAttr::AT_Consumable:
handleConsumableAttr(S, D, AL);
break;
- case AttributeList::AT_ConsumableAutoCast:
+ case ParsedAttr::AT_ConsumableAutoCast:
handleSimpleAttribute<ConsumableAutoCastAttr>(S, D, AL);
break;
- case AttributeList::AT_ConsumableSetOnRead:
+ case ParsedAttr::AT_ConsumableSetOnRead:
handleSimpleAttribute<ConsumableSetOnReadAttr>(S, D, AL);
break;
- case AttributeList::AT_CallableWhen:
+ case ParsedAttr::AT_CallableWhen:
handleCallableWhenAttr(S, D, AL);
break;
- case AttributeList::AT_ParamTypestate:
+ case ParsedAttr::AT_ParamTypestate:
handleParamTypestateAttr(S, D, AL);
break;
- case AttributeList::AT_ReturnTypestate:
+ case ParsedAttr::AT_ReturnTypestate:
handleReturnTypestateAttr(S, D, AL);
break;
- case AttributeList::AT_SetTypestate:
+ case ParsedAttr::AT_SetTypestate:
handleSetTypestateAttr(S, D, AL);
break;
- case AttributeList::AT_TestTypestate:
+ case ParsedAttr::AT_TestTypestate:
handleTestTypestateAttr(S, D, AL);
break;
// Type safety attributes.
- case AttributeList::AT_ArgumentWithTypeTag:
+ case ParsedAttr::AT_ArgumentWithTypeTag:
handleArgumentWithTypeTagAttr(S, D, AL);
break;
- case AttributeList::AT_TypeTagForDatatype:
+ case ParsedAttr::AT_TypeTagForDatatype:
handleTypeTagForDatatypeAttr(S, D, AL);
break;
- case AttributeList::AT_AnyX86NoCallerSavedRegisters:
+ case ParsedAttr::AT_AnyX86NoCallerSavedRegisters:
handleSimpleAttribute<AnyX86NoCallerSavedRegistersAttr>(S, D, AL);
break;
- case AttributeList::AT_RenderScriptKernel:
+ case ParsedAttr::AT_RenderScriptKernel:
handleSimpleAttribute<RenderScriptKernelAttr>(S, D, AL);
break;
// XRay attributes.
- case AttributeList::AT_XRayInstrument:
+ case ParsedAttr::AT_XRayInstrument:
handleSimpleAttribute<XRayInstrumentAttr>(S, D, AL);
break;
- case AttributeList::AT_XRayLogArgs:
+ case ParsedAttr::AT_XRayLogArgs:
handleXRayLogArgsAttr(S, D, AL);
break;
}
@@ -6462,7 +6437,7 @@
if (AttrList.empty())
return;
- for (const AttributeList &AL : AttrList)
+ for (const ParsedAttr &AL : AttrList)
ProcessDeclAttribute(*this, S, D, AL, IncludeCXX11Attributes);
// FIXME: We should be able to handle these cases in TableGen.
@@ -6521,8 +6496,8 @@
// Helper for delayed processing TransparentUnion attribute.
void Sema::ProcessDeclAttributeDelayed(Decl *D,
const ParsedAttributesView &AttrList) {
- for (const AttributeList &AL : AttrList)
- if (AL.getKind() == AttributeList::AT_TransparentUnion) {
+ for (const ParsedAttr &AL : AttrList)
+ if (AL.getKind() == ParsedAttr::AT_TransparentUnion) {
handleTransparentUnionAttr(*this, D, AL);
break;
}
@@ -6532,8 +6507,8 @@
// specifier.
bool Sema::ProcessAccessDeclAttributeList(
AccessSpecDecl *ASDecl, const ParsedAttributesView &AttrList) {
- for (const AttributeList &AL : AttrList) {
- if (AL.getKind() == AttributeList::AT_Annotate) {
+ for (const ParsedAttr &AL : AttrList) {
+ if (AL.getKind() == ParsedAttr::AT_Annotate) {
ProcessDeclAttribute(*this, nullptr, ASDecl, AL, AL.isCXX11Attribute());
} else {
Diag(AL.getLoc(), diag::err_only_annotate_after_access_spec);
@@ -6546,14 +6521,14 @@
/// checkUnusedDeclAttributes - Check a list of attributes to see if it
/// contains any decl attributes that we should warn about.
static void checkUnusedDeclAttributes(Sema &S, const ParsedAttributesView &A) {
- for (const AttributeList &AL : A) {
+ for (const ParsedAttr &AL : A) {
// Only warn if the attribute is an unignored, non-type attribute.
if (AL.isUsedAsTypeAttr() || AL.isInvalid())
continue;
- if (AL.getKind() == AttributeList::IgnoredAttribute)
+ if (AL.getKind() == ParsedAttr::IgnoredAttribute)
continue;
- if (AL.getKind() == AttributeList::UnknownAttribute) {
+ if (AL.getKind() == ParsedAttr::UnknownAttribute) {
S.Diag(AL.getLoc(), diag::warn_unknown_attribute_ignored)
<< AL.getName() << AL.getRange();
} else {
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index 6f411ca..63d01c9 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -2300,10 +2300,10 @@
// We do not support any C++11 attributes on base-specifiers yet.
// Diagnose any attributes we see.
- for (const AttributeList &AL : Attributes) {
- if (AL.isInvalid() || AL.getKind() == AttributeList::IgnoredAttribute)
+ for (const ParsedAttr &AL : Attributes) {
+ if (AL.isInvalid() || AL.getKind() == ParsedAttr::IgnoredAttribute)
continue;
- Diag(AL.getLoc(), AL.getKind() == AttributeList::UnknownAttribute
+ Diag(AL.getLoc(), AL.getKind() == ParsedAttr::UnknownAttribute
? diag::warn_unknown_attribute_ignored
: diag::err_base_specifier_attribute)
<< AL.getName();
@@ -2816,10 +2816,9 @@
return false;
}
-static const AttributeList *
-getMSPropertyAttr(const ParsedAttributesView &list) {
+static const ParsedAttr *getMSPropertyAttr(const ParsedAttributesView &list) {
ParsedAttributesView::const_iterator Itr =
- llvm::find_if(list, [](const AttributeList &AL) {
+ llvm::find_if(list, [](const ParsedAttr &AL) {
return AL.isDeclspecPropertyAttribute();
});
if (Itr != list.end())
@@ -2902,7 +2901,7 @@
assert(!DS.isFriendSpecified());
bool isFunc = D.isDeclarationOfFunction();
- const AttributeList *MSPropertyAttr =
+ const ParsedAttr *MSPropertyAttr =
getMSPropertyAttr(D.getDeclSpec().getAttributes());
if (cast<CXXRecordDecl>(CurContext)->isInterface()) {
@@ -7815,8 +7814,8 @@
AdjustDeclIfTemplate(TagDecl);
- for (const AttributeList &AL : AttrList) {
- if (AL.getKind() != AttributeList::AT_Visibility)
+ for (const ParsedAttr &AL : AttrList) {
+ if (AL.getKind() != ParsedAttr::AT_Visibility)
continue;
AL.setInvalid();
Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored)
@@ -15388,7 +15387,7 @@
Expr *BitWidth,
InClassInitStyle InitStyle,
AccessSpecifier AS,
- const AttributeList &MSPropertyAttr) {
+ const ParsedAttr &MSPropertyAttr) {
IdentifierInfo *II = D.getIdentifier();
if (!II) {
Diag(DeclStart, diag::err_anonymous_property);
@@ -15451,7 +15450,7 @@
PrevDecl = nullptr;
SourceLocation TSSL = D.getLocStart();
- const AttributeList::PropertyData &Data = MSPropertyAttr.getPropertyData();
+ const ParsedAttr::PropertyData &Data = MSPropertyAttr.getPropertyData();
MSPropertyDecl *NewPD = MSPropertyDecl::Create(
Context, Record, Loc, II, T, TInfo, TSSL, Data.GetterId, Data.SetterId);
ProcessDeclAttributes(TUScope, NewPD, D);
diff --git a/clang/lib/Sema/SemaStmtAttr.cpp b/clang/lib/Sema/SemaStmtAttr.cpp
index dbd967c..e39a65c 100644
--- a/clang/lib/Sema/SemaStmtAttr.cpp
+++ b/clang/lib/Sema/SemaStmtAttr.cpp
@@ -23,7 +23,7 @@
using namespace clang;
using namespace sema;
-static Attr *handleFallThroughAttr(Sema &S, Stmt *St, const AttributeList &A,
+static Attr *handleFallThroughAttr(Sema &S, Stmt *St, const ParsedAttr &A,
SourceRange Range) {
FallThroughAttr Attr(A.getRange(), S.Context,
A.getAttributeSpellingListIndex());
@@ -53,7 +53,7 @@
return ::new (S.Context) auto(Attr);
}
-static Attr *handleSuppressAttr(Sema &S, Stmt *St, const AttributeList &A,
+static Attr *handleSuppressAttr(Sema &S, Stmt *St, const ParsedAttr &A,
SourceRange Range) {
if (A.getNumArgs() < 1) {
S.Diag(A.getLoc(), diag::err_attribute_too_few_arguments)
@@ -78,7 +78,7 @@
DiagnosticIdentifiers.size(), A.getAttributeSpellingListIndex());
}
-static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const AttributeList &A,
+static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const ParsedAttr &A,
SourceRange) {
IdentifierLoc *PragmaNameLoc = A.getArgAsIdent(0);
IdentifierLoc *OptionLoc = A.getArgAsIdent(1);
@@ -246,7 +246,7 @@
}
}
-static Attr *handleOpenCLUnrollHint(Sema &S, Stmt *St, const AttributeList &A,
+static Attr *handleOpenCLUnrollHint(Sema &S, Stmt *St, const ParsedAttr &A,
SourceRange Range) {
// Although the feature was introduced only in OpenCL C v2.0 s6.11.5, it's
// useful for OpenCL 1.x too and doesn't require HW support.
@@ -288,21 +288,21 @@
return OpenCLUnrollHintAttr::CreateImplicit(S.Context, UnrollFactor);
}
-static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const AttributeList &A,
+static Attr *ProcessStmtAttribute(Sema &S, Stmt *St, const ParsedAttr &A,
SourceRange Range) {
switch (A.getKind()) {
- case AttributeList::UnknownAttribute:
+ case ParsedAttr::UnknownAttribute:
S.Diag(A.getLoc(), A.isDeclspecAttribute() ?
diag::warn_unhandled_ms_attribute_ignored :
diag::warn_unknown_attribute_ignored) << A.getName();
return nullptr;
- case AttributeList::AT_FallThrough:
+ case ParsedAttr::AT_FallThrough:
return handleFallThroughAttr(S, St, A, Range);
- case AttributeList::AT_LoopHint:
+ case ParsedAttr::AT_LoopHint:
return handleLoopHintAttr(S, St, A, Range);
- case AttributeList::AT_OpenCLUnrollHint:
+ case ParsedAttr::AT_OpenCLUnrollHint:
return handleOpenCLUnrollHint(S, St, A, Range);
- case AttributeList::AT_Suppress:
+ case ParsedAttr::AT_Suppress:
return handleSuppressAttr(S, St, A, Range);
default:
// if we're here, then we parsed a known attribute, but didn't recognize
@@ -317,7 +317,7 @@
const ParsedAttributesView &AttrList,
SourceRange Range) {
SmallVector<const Attr*, 8> Attrs;
- for (const AttributeList &AL : AttrList) {
+ for (const ParsedAttr &AL : AttrList) {
if (Attr *a = ProcessStmtAttribute(*this, S, AL, Range))
Attrs.push_back(a);
}
diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp
index 276a617..e78fd43 100644
--- a/clang/lib/Sema/SemaTemplate.cpp
+++ b/clang/lib/Sema/SemaTemplate.cpp
@@ -8599,8 +8599,8 @@
if (TSK == TSK_ExplicitInstantiationDeclaration) {
// Check for dllexport class template instantiation declarations.
- for (const AttributeList &AL : Attr) {
- if (AL.getKind() == AttributeList::AT_DLLExport) {
+ for (const ParsedAttr &AL : Attr) {
+ if (AL.getKind() == ParsedAttr::AT_DLLExport) {
Diag(ExternLoc,
diag::warn_attribute_dllexport_explicit_instantiation_decl);
Diag(AL.getLoc(), diag::note_attribute);
@@ -8623,10 +8623,10 @@
// Check for dllimport class template instantiation definitions.
bool DLLImport =
ClassTemplate->getTemplatedDecl()->getAttr<DLLImportAttr>();
- for (const AttributeList &AL : Attr) {
- if (AL.getKind() == AttributeList::AT_DLLImport)
+ for (const ParsedAttr &AL : Attr) {
+ if (AL.getKind() == ParsedAttr::AT_DLLImport)
DLLImport = true;
- if (AL.getKind() == AttributeList::AT_DLLExport) {
+ if (AL.getKind() == ParsedAttr::AT_DLLExport) {
// dllexport trumps dllimport here.
DLLImport = false;
break;
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 18c5ce7..641a2f5 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -64,13 +64,17 @@
/// diagnoseBadTypeAttribute - Diagnoses a type attribute which
/// doesn't apply to the given type.
-static void diagnoseBadTypeAttribute(Sema &S, const AttributeList &attr,
+static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr,
QualType type) {
TypeDiagSelector WhichType;
bool useExpansionLoc = true;
switch (attr.getKind()) {
- case AttributeList::AT_ObjCGC: WhichType = TDS_Pointer; break;
- case AttributeList::AT_ObjCOwnership: WhichType = TDS_ObjCObjOrBlock; break;
+ case ParsedAttr::AT_ObjCGC:
+ WhichType = TDS_Pointer;
+ break;
+ case ParsedAttr::AT_ObjCOwnership:
+ WhichType = TDS_ObjCObjOrBlock;
+ break;
default:
// Assume everything else was a function attribute.
WhichType = TDS_Function;
@@ -98,48 +102,48 @@
// objc_gc applies to Objective-C pointers or, otherwise, to the
// smallest available pointer type (i.e. 'void*' in 'void**').
-#define OBJC_POINTER_TYPE_ATTRS_CASELIST \
- case AttributeList::AT_ObjCGC: \
- case AttributeList::AT_ObjCOwnership
+#define OBJC_POINTER_TYPE_ATTRS_CASELIST \
+ case ParsedAttr::AT_ObjCGC: \
+ case ParsedAttr::AT_ObjCOwnership
// Calling convention attributes.
-#define CALLING_CONV_ATTRS_CASELIST \
- case AttributeList::AT_CDecl: \
- case AttributeList::AT_FastCall: \
- case AttributeList::AT_StdCall: \
- case AttributeList::AT_ThisCall: \
- case AttributeList::AT_RegCall: \
- case AttributeList::AT_Pascal: \
- case AttributeList::AT_SwiftCall: \
- case AttributeList::AT_VectorCall: \
- case AttributeList::AT_MSABI: \
- case AttributeList::AT_SysVABI: \
- case AttributeList::AT_Pcs: \
- case AttributeList::AT_IntelOclBicc: \
- case AttributeList::AT_PreserveMost: \
- case AttributeList::AT_PreserveAll
+#define CALLING_CONV_ATTRS_CASELIST \
+ case ParsedAttr::AT_CDecl: \
+ case ParsedAttr::AT_FastCall: \
+ case ParsedAttr::AT_StdCall: \
+ case ParsedAttr::AT_ThisCall: \
+ case ParsedAttr::AT_RegCall: \
+ case ParsedAttr::AT_Pascal: \
+ case ParsedAttr::AT_SwiftCall: \
+ case ParsedAttr::AT_VectorCall: \
+ case ParsedAttr::AT_MSABI: \
+ case ParsedAttr::AT_SysVABI: \
+ case ParsedAttr::AT_Pcs: \
+ case ParsedAttr::AT_IntelOclBicc: \
+ case ParsedAttr::AT_PreserveMost: \
+ case ParsedAttr::AT_PreserveAll
// Function type attributes.
-#define FUNCTION_TYPE_ATTRS_CASELIST \
- case AttributeList::AT_NSReturnsRetained: \
- case AttributeList::AT_NoReturn: \
- case AttributeList::AT_Regparm: \
- case AttributeList::AT_AnyX86NoCallerSavedRegisters: \
- case AttributeList::AT_AnyX86NoCfCheck: \
+#define FUNCTION_TYPE_ATTRS_CASELIST \
+ case ParsedAttr::AT_NSReturnsRetained: \
+ case ParsedAttr::AT_NoReturn: \
+ case ParsedAttr::AT_Regparm: \
+ case ParsedAttr::AT_AnyX86NoCallerSavedRegisters: \
+ case ParsedAttr::AT_AnyX86NoCfCheck: \
CALLING_CONV_ATTRS_CASELIST
// Microsoft-specific type qualifiers.
-#define MS_TYPE_ATTRS_CASELIST \
- case AttributeList::AT_Ptr32: \
- case AttributeList::AT_Ptr64: \
- case AttributeList::AT_SPtr: \
- case AttributeList::AT_UPtr
+#define MS_TYPE_ATTRS_CASELIST \
+ case ParsedAttr::AT_Ptr32: \
+ case ParsedAttr::AT_Ptr64: \
+ case ParsedAttr::AT_SPtr: \
+ case ParsedAttr::AT_UPtr
// Nullability qualifiers.
-#define NULLABILITY_TYPE_ATTRS_CASELIST \
- case AttributeList::AT_TypeNonNull: \
- case AttributeList::AT_TypeNullable: \
- case AttributeList::AT_TypeNullUnspecified
+#define NULLABILITY_TYPE_ATTRS_CASELIST \
+ case ParsedAttr::AT_TypeNonNull: \
+ case ParsedAttr::AT_TypeNullable: \
+ case ParsedAttr::AT_TypeNullUnspecified
namespace {
/// An object which stores processing state for the entire
@@ -162,11 +166,11 @@
bool hasSavedAttrs;
/// The original set of attributes on the DeclSpec.
- SmallVector<AttributeList*, 2> savedAttrs;
+ SmallVector<ParsedAttr *, 2> savedAttrs;
/// A list of attributes to diagnose the uselessness of when the
/// processing is complete.
- SmallVector<AttributeList*, 2> ignoredTypeAttrs;
+ SmallVector<ParsedAttr *, 2> ignoredTypeAttrs;
public:
TypeProcessingState(Sema &sema, Declarator &declarator)
@@ -207,7 +211,7 @@
if (hasSavedAttrs) return;
DeclSpec &spec = getMutableDeclSpec();
- for (AttributeList &AL : spec.getAttributes())
+ for (ParsedAttr &AL : spec.getAttributes())
savedAttrs.push_back(&AL);
trivial &= savedAttrs.empty();
hasSavedAttrs = true;
@@ -215,7 +219,7 @@
/// Record that we had nowhere to put the given type attribute.
/// We will diagnose such attributes later.
- void addIgnoredTypeAttr(AttributeList &attr) {
+ void addIgnoredTypeAttr(ParsedAttr &attr) {
ignoredTypeAttrs.push_back(&attr);
}
@@ -241,13 +245,13 @@
assert(hasSavedAttrs);
getMutableDeclSpec().getAttributes().clearListOnly();
- for (AttributeList *AL : savedAttrs)
+ for (ParsedAttr *AL : savedAttrs)
getMutableDeclSpec().getAttributes().addAtStart(AL);
}
};
} // end anonymous namespace
-static void moveAttrFromListToList(AttributeList &attr,
+static void moveAttrFromListToList(ParsedAttr &attr,
ParsedAttributesView &fromList,
ParsedAttributesView &toList) {
fromList.remove(&attr);
@@ -267,25 +271,23 @@
static void processTypeAttrs(TypeProcessingState &state, QualType &type,
TypeAttrLocation TAL, ParsedAttributesView &attrs);
-static bool handleFunctionTypeAttr(TypeProcessingState &state,
- AttributeList &attr,
+static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
QualType &type);
static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state,
- AttributeList &attr,
- QualType &type);
+ ParsedAttr &attr, QualType &type);
-static bool handleObjCGCTypeAttr(TypeProcessingState &state,
- AttributeList &attr, QualType &type);
+static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
+ QualType &type);
static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state,
- AttributeList &attr, QualType &type);
+ ParsedAttr &attr, QualType &type);
static bool handleObjCPointerTypeAttr(TypeProcessingState &state,
- AttributeList &attr, QualType &type) {
- if (attr.getKind() == AttributeList::AT_ObjCGC)
+ ParsedAttr &attr, QualType &type) {
+ if (attr.getKind() == ParsedAttr::AT_ObjCGC)
return handleObjCGCTypeAttr(state, attr, type);
- assert(attr.getKind() == AttributeList::AT_ObjCOwnership);
+ assert(attr.getKind() == ParsedAttr::AT_ObjCOwnership);
return handleObjCOwnershipTypeAttr(state, attr, type);
}
@@ -367,8 +369,7 @@
/// didn't apply in whatever position it was written in, try to move
/// it to a more appropriate position.
static void distributeObjCPointerTypeAttr(TypeProcessingState &state,
- AttributeList &attr,
- QualType type) {
+ ParsedAttr &attr, QualType type) {
Declarator &declarator = state.getDeclarator();
// Move it to the outermost normal or block pointer declarator.
@@ -381,7 +382,7 @@
// of a block.
DeclaratorChunk *destChunk = nullptr;
if (state.isProcessingDeclSpec() &&
- attr.getKind() == AttributeList::AT_ObjCOwnership)
+ attr.getKind() == ParsedAttr::AT_ObjCOwnership)
destChunk = maybeMovePastReturnType(declarator, i - 1,
/*onlyBlockPointers=*/true);
if (!destChunk) destChunk = &chunk;
@@ -398,7 +399,7 @@
// We may be starting at the return type of a block.
case DeclaratorChunk::Function:
if (state.isProcessingDeclSpec() &&
- attr.getKind() == AttributeList::AT_ObjCOwnership) {
+ attr.getKind() == ParsedAttr::AT_ObjCOwnership) {
if (DeclaratorChunk *dest = maybeMovePastReturnType(
declarator, i,
/*onlyBlockPointers=*/true)) {
@@ -423,10 +424,8 @@
/// Distribute an objc_gc type attribute that was written on the
/// declarator.
-static void
-distributeObjCPointerTypeAttrFromDeclarator(TypeProcessingState &state,
- AttributeList &attr,
- QualType &declSpecType) {
+static void distributeObjCPointerTypeAttrFromDeclarator(
+ TypeProcessingState &state, ParsedAttr &attr, QualType &declSpecType) {
Declarator &declarator = state.getDeclarator();
// objc_gc goes on the innermost pointer to something that's not a
@@ -487,8 +486,7 @@
/// that it didn't apply in whatever position it was written in, try
/// to move it to a more appropriate position.
static void distributeFunctionTypeAttr(TypeProcessingState &state,
- AttributeList &attr,
- QualType type) {
+ ParsedAttr &attr, QualType type) {
Declarator &declarator = state.getDeclarator();
// Try to push the attribute from the return type of a function to
@@ -519,7 +517,7 @@
/// function chunk or type. Returns true if the attribute was
/// distributed, false if no location was found.
static bool distributeFunctionTypeAttrToInnermost(
- TypeProcessingState &state, AttributeList &attr,
+ TypeProcessingState &state, ParsedAttr &attr,
ParsedAttributesView &attrList, QualType &declSpecType) {
Declarator &declarator = state.getDeclarator();
@@ -537,10 +535,9 @@
/// A function type attribute was written in the decl spec. Try to
/// apply it somewhere.
-static void
-distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state,
- AttributeList &attr,
- QualType &declSpecType) {
+static void distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state,
+ ParsedAttr &attr,
+ QualType &declSpecType) {
state.saveDeclSpecAttrs();
// C++11 attributes before the decl specifiers actually appertain to
@@ -564,10 +561,9 @@
/// A function type attribute was written on the declarator. Try to
/// apply it somewhere.
-static void
-distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state,
- AttributeList &attr,
- QualType &declSpecType) {
+static void distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state,
+ ParsedAttr &attr,
+ QualType &declSpecType) {
Declarator &declarator = state.getDeclarator();
// Try to distribute to the innermost.
@@ -599,7 +595,7 @@
// list, so iterating over the existing list isn't possible. Instead, make a
// non-owning copy and iterate over that.
ParsedAttributesView AttrsCopy{state.getDeclarator().getAttributes()};
- for (AttributeList &attr : AttrsCopy) {
+ for (ParsedAttr &attr : AttrsCopy) {
// Do not distribute C++11 attributes. They have strict rules for what
// they appertain to.
if (attr.isCXX11Attribute())
@@ -622,7 +618,7 @@
// Nullability specifiers cannot go after the declarator-id.
// Objective-C __kindof does not get distributed.
- case AttributeList::AT_ObjCKindOf:
+ case ParsedAttr::AT_ObjCKindOf:
continue;
default:
@@ -728,8 +724,8 @@
return false;
// Warn if we see type attributes for omitted return type on a block literal.
- SmallVector<AttributeList *, 2> ToBeRemoved;
- for (AttributeList &AL : declarator.getMutableDeclSpec().getAttributes()) {
+ SmallVector<ParsedAttr *, 2> ToBeRemoved;
+ for (ParsedAttr &AL : declarator.getMutableDeclSpec().getAttributes()) {
if (AL.isInvalid() || !AL.isTypeAttr())
continue;
S.Diag(AL.getLoc(),
@@ -738,7 +734,7 @@
ToBeRemoved.push_back(&AL);
}
// Remove bad attributes from the list.
- for (AttributeList *AL : ToBeRemoved)
+ for (ParsedAttr *AL : ToBeRemoved)
declarator.getMutableDeclSpec().getAttributes().remove(AL);
// Warn if we see type qualifiers for omitted return type on a block literal.
@@ -1169,8 +1165,8 @@
static OpenCLAccessAttr::Spelling
getImageAccess(const ParsedAttributesView &Attrs) {
- for (const AttributeList &AL : Attrs)
- if (AL.getKind() == AttributeList::AT_OpenCLAccess)
+ for (const ParsedAttr &AL : Attrs)
+ if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
return static_cast<OpenCLAccessAttr::Spelling>(AL.getSemanticSpelling());
return OpenCLAccessAttr::Keyword_read_only;
}
@@ -2599,8 +2595,8 @@
if (chunk.Kind != DeclaratorChunk::Pointer &&
chunk.Kind != DeclaratorChunk::BlockPointer)
return;
- for (const AttributeList &AL : chunk.getAttrs())
- if (AL.getKind() == AttributeList::AT_ObjCOwnership)
+ for (const ParsedAttr &AL : chunk.getAttrs())
+ if (AL.getKind() == ParsedAttr::AT_ObjCOwnership)
return;
transferARCOwnershipToDeclaratorChunk(state, Qualifiers::OCL_Autoreleasing,
@@ -3272,7 +3268,7 @@
assert(D.getTypeObject(ChunkIndex).Kind == DeclaratorChunk::Function);
// Check for an explicit CC attribute.
- for (const AttributeList &AL : AttrList) {
+ for (const ParsedAttr &AL : AttrList) {
switch (AL.getKind()) {
CALLING_CONV_ATTRS_CASELIST : {
// Ignore attributes that don't validate or can't apply to the
@@ -3335,8 +3331,8 @@
// convention attribute. This is the simplest place to infer
// calling convention for OpenCL kernels.
if (S.getLangOpts().OpenCL) {
- for (const AttributeList &AL : D.getDeclSpec().getAttributes()) {
- if (AL.getKind() == AttributeList::AT_OpenCLKernel) {
+ for (const ParsedAttr &AL : D.getDeclSpec().getAttributes()) {
+ if (AL.getKind() == ParsedAttr::AT_OpenCLKernel) {
CC = CC_OpenCLKernel;
break;
}
@@ -3388,10 +3384,10 @@
/// Check whether there is a nullability attribute of any kind in the given
/// attribute list.
static bool hasNullabilityAttr(const ParsedAttributesView &attrs) {
- for (const AttributeList &AL : attrs) {
- if (AL.getKind() == AttributeList::AT_TypeNonNull ||
- AL.getKind() == AttributeList::AT_TypeNullable ||
- AL.getKind() == AttributeList::AT_TypeNullUnspecified)
+ for (const ParsedAttr &AL : attrs) {
+ if (AL.getKind() == ParsedAttr::AT_TypeNonNull ||
+ AL.getKind() == ParsedAttr::AT_TypeNullable ||
+ AL.getKind() == ParsedAttr::AT_TypeNullUnspecified)
return true;
}
@@ -3995,9 +3991,8 @@
// infer the inner pointer as _Nullable.
auto hasCFReturnsAttr =
[](const ParsedAttributesView &AttrList) -> bool {
- return AttrList.hasAttribute(AttributeList::AT_CFReturnsRetained) ||
- AttrList.hasAttribute(
- AttributeList::AT_CFReturnsNotRetained);
+ return AttrList.hasAttribute(ParsedAttr::AT_CFReturnsRetained) ||
+ AttrList.hasAttribute(ParsedAttr::AT_CFReturnsNotRetained);
};
if (const auto *InnermostChunk = D.getInnermostNonParenChunk()) {
if (hasCFReturnsAttr(D.getAttributes()) ||
@@ -4061,7 +4056,7 @@
auto inferPointerNullability =
[&](SimplePointerKind pointerKind, SourceLocation pointerLoc,
SourceLocation pointerEndLoc,
- ParsedAttributesView &attrs) -> AttributeList * {
+ ParsedAttributesView &attrs) -> ParsedAttr * {
// We've seen a pointer.
if (NumPointersRemaining > 0)
--NumPointersRemaining;
@@ -4072,16 +4067,14 @@
// If we're supposed to infer nullability, do so now.
if (inferNullability && !inferNullabilityInnerOnlyComplete) {
- AttributeList::Syntax syntax
- = inferNullabilityCS ? AttributeList::AS_ContextSensitiveKeyword
- : AttributeList::AS_Keyword;
- AttributeList *nullabilityAttr = state.getDeclarator().getAttributePool()
- .create(
- S.getNullabilityKeyword(
- *inferNullability),
- SourceRange(pointerLoc),
- nullptr, SourceLocation(),
- nullptr, 0, syntax);
+ ParsedAttr::Syntax syntax = inferNullabilityCS
+ ? ParsedAttr::AS_ContextSensitiveKeyword
+ : ParsedAttr::AS_Keyword;
+ ParsedAttr *nullabilityAttr =
+ state.getDeclarator().getAttributePool().create(
+ S.getNullabilityKeyword(*inferNullability),
+ SourceRange(pointerLoc), nullptr, SourceLocation(), nullptr, 0,
+ syntax);
attrs.addAtStart(nullabilityAttr);
@@ -4474,16 +4467,16 @@
SourceLocation AttrLoc;
if (chunkIndex + 1 < D.getNumTypeObjects()) {
DeclaratorChunk ReturnTypeChunk = D.getTypeObject(chunkIndex + 1);
- for (const AttributeList &AL : ReturnTypeChunk.getAttrs()) {
- if (AL.getKind() == AttributeList::AT_ObjCOwnership) {
+ for (const ParsedAttr &AL : ReturnTypeChunk.getAttrs()) {
+ if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
AttrLoc = AL.getLoc();
break;
}
}
}
if (AttrLoc.isInvalid()) {
- for (const AttributeList &AL : D.getDeclSpec().getAttributes()) {
- if (AL.getKind() == AttributeList::AT_ObjCOwnership) {
+ for (const ParsedAttr &AL : D.getDeclSpec().getAttributes()) {
+ if (AL.getKind() == ParsedAttr::AT_ObjCOwnership) {
AttrLoc = AL.getLoc();
break;
}
@@ -4536,7 +4529,7 @@
// function is marked with the "overloadable" attribute. Scan
// for this attribute now.
if (!FTI.NumParams && FTI.isVariadic && !LangOpts.CPlusPlus)
- if (!D.getAttributes().hasAttribute(AttributeList::AT_Overloadable))
+ if (!D.getAttributes().hasAttribute(ParsedAttr::AT_Overloadable))
S.Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_param);
if (FTI.NumParams && FTI.Params[0].Param == nullptr) {
@@ -5024,7 +5017,7 @@
// Look for an explicit lifetime attribute.
DeclaratorChunk &chunk = D.getTypeObject(chunkIndex);
- if (chunk.getAttrs().hasAttribute(AttributeList::AT_ObjCOwnership))
+ if (chunk.getAttrs().hasAttribute(ParsedAttr::AT_ObjCOwnership))
return;
const char *attrStr = nullptr;
@@ -5044,10 +5037,10 @@
// If there wasn't one, add one (with an invalid source location
// so that we don't make an AttributedType for it).
- AttributeList *attr = D.getAttributePool()
- .create(&S.Context.Idents.get("objc_ownership"), SourceLocation(),
- /*scope*/ nullptr, SourceLocation(),
- /*args*/ &Args, 1, AttributeList::AS_GNU);
+ ParsedAttr *attr = D.getAttributePool().create(
+ &S.Context.Idents.get("objc_ownership"), SourceLocation(),
+ /*scope*/ nullptr, SourceLocation(),
+ /*args*/ &Args, 1, ParsedAttr::AS_GNU);
chunk.getAttrs().addAtStart(attr);
// TODO: mark whether we did this inference?
}
@@ -5119,81 +5112,80 @@
return GetFullTypeForDeclarator(state, declSpecTy, ReturnTypeInfo);
}
-/// Map an AttributedType::Kind to an AttributeList::Kind.
-static AttributeList::Kind getAttrListKind(AttributedType::Kind kind) {
+/// Map an AttributedType::Kind to an ParsedAttr::Kind.
+static ParsedAttr::Kind getAttrListKind(AttributedType::Kind kind) {
switch (kind) {
case AttributedType::attr_address_space:
- return AttributeList::AT_AddressSpace;
+ return ParsedAttr::AT_AddressSpace;
case AttributedType::attr_regparm:
- return AttributeList::AT_Regparm;
+ return ParsedAttr::AT_Regparm;
case AttributedType::attr_vector_size:
- return AttributeList::AT_VectorSize;
+ return ParsedAttr::AT_VectorSize;
case AttributedType::attr_neon_vector_type:
- return AttributeList::AT_NeonVectorType;
+ return ParsedAttr::AT_NeonVectorType;
case AttributedType::attr_neon_polyvector_type:
- return AttributeList::AT_NeonPolyVectorType;
+ return ParsedAttr::AT_NeonPolyVectorType;
case AttributedType::attr_objc_gc:
- return AttributeList::AT_ObjCGC;
+ return ParsedAttr::AT_ObjCGC;
case AttributedType::attr_objc_ownership:
case AttributedType::attr_objc_inert_unsafe_unretained:
- return AttributeList::AT_ObjCOwnership;
+ return ParsedAttr::AT_ObjCOwnership;
case AttributedType::attr_noreturn:
- return AttributeList::AT_NoReturn;
+ return ParsedAttr::AT_NoReturn;
case AttributedType::attr_nocf_check:
- return AttributeList::AT_AnyX86NoCfCheck;
+ return ParsedAttr::AT_AnyX86NoCfCheck;
case AttributedType::attr_cdecl:
- return AttributeList::AT_CDecl;
+ return ParsedAttr::AT_CDecl;
case AttributedType::attr_fastcall:
- return AttributeList::AT_FastCall;
+ return ParsedAttr::AT_FastCall;
case AttributedType::attr_stdcall:
- return AttributeList::AT_StdCall;
+ return ParsedAttr::AT_StdCall;
case AttributedType::attr_thiscall:
- return AttributeList::AT_ThisCall;
+ return ParsedAttr::AT_ThisCall;
case AttributedType::attr_regcall:
- return AttributeList::AT_RegCall;
+ return ParsedAttr::AT_RegCall;
case AttributedType::attr_pascal:
- return AttributeList::AT_Pascal;
+ return ParsedAttr::AT_Pascal;
case AttributedType::attr_swiftcall:
- return AttributeList::AT_SwiftCall;
+ return ParsedAttr::AT_SwiftCall;
case AttributedType::attr_vectorcall:
- return AttributeList::AT_VectorCall;
+ return ParsedAttr::AT_VectorCall;
case AttributedType::attr_pcs:
case AttributedType::attr_pcs_vfp:
- return AttributeList::AT_Pcs;
+ return ParsedAttr::AT_Pcs;
case AttributedType::attr_inteloclbicc:
- return AttributeList::AT_IntelOclBicc;
+ return ParsedAttr::AT_IntelOclBicc;
case AttributedType::attr_ms_abi:
- return AttributeList::AT_MSABI;
+ return ParsedAttr::AT_MSABI;
case AttributedType::attr_sysv_abi:
- return AttributeList::AT_SysVABI;
+ return ParsedAttr::AT_SysVABI;
case AttributedType::attr_preserve_most:
- return AttributeList::AT_PreserveMost;
+ return ParsedAttr::AT_PreserveMost;
case AttributedType::attr_preserve_all:
- return AttributeList::AT_PreserveAll;
+ return ParsedAttr::AT_PreserveAll;
case AttributedType::attr_ptr32:
- return AttributeList::AT_Ptr32;
+ return ParsedAttr::AT_Ptr32;
case AttributedType::attr_ptr64:
- return AttributeList::AT_Ptr64;
+ return ParsedAttr::AT_Ptr64;
case AttributedType::attr_sptr:
- return AttributeList::AT_SPtr;
+ return ParsedAttr::AT_SPtr;
case AttributedType::attr_uptr:
- return AttributeList::AT_UPtr;
+ return ParsedAttr::AT_UPtr;
case AttributedType::attr_nonnull:
- return AttributeList::AT_TypeNonNull;
+ return ParsedAttr::AT_TypeNonNull;
case AttributedType::attr_nullable:
- return AttributeList::AT_TypeNullable;
+ return ParsedAttr::AT_TypeNullable;
case AttributedType::attr_null_unspecified:
- return AttributeList::AT_TypeNullUnspecified;
+ return ParsedAttr::AT_TypeNullUnspecified;
case AttributedType::attr_objc_kindof:
- return AttributeList::AT_ObjCKindOf;
+ return ParsedAttr::AT_ObjCKindOf;
case AttributedType::attr_ns_returns_retained:
- return AttributeList::AT_NSReturnsRetained;
+ return ParsedAttr::AT_NSReturnsRetained;
}
llvm_unreachable("unexpected attribute kind!");
}
-static void setAttributedTypeLoc(AttributedTypeLoc TL,
- const AttributeList &attr) {
+static void setAttributedTypeLoc(AttributedTypeLoc TL, const ParsedAttr &attr) {
TL.setAttrNameLoc(attr.getLoc());
if (TL.hasAttrExprOperand()) {
assert(attr.isArgExpr(0) && "mismatched attribute operand kind");
@@ -5219,13 +5211,13 @@
assert((!Attrs.empty() || !DeclAttrs.empty()) &&
"no type attributes in the expected location!");
- AttributeList::Kind parsedKind = getAttrListKind(TL.getAttrKind());
+ ParsedAttr::Kind parsedKind = getAttrListKind(TL.getAttrKind());
// Try to search for an attribute of matching kind in Attrs list.
- for (const AttributeList &AL : Attrs)
+ for (const ParsedAttr &AL : Attrs)
if (AL.getKind() == parsedKind)
return setAttributedTypeLoc(TL, AL);
- for (const AttributeList &AL : DeclAttrs)
+ for (const ParsedAttr &AL : DeclAttrs)
if (AL.isCXX11Attribute() || AL.getKind() == parsedKind)
return setAttributedTypeLoc(TL, AL);
llvm_unreachable("no matching type attribute in expected location!");
@@ -5549,8 +5541,8 @@
static void
fillDependentAddressSpaceTypeLoc(DependentAddressSpaceTypeLoc DASTL,
const ParsedAttributesView &Attrs) {
- for (const AttributeList &AL : Attrs) {
- if (AL.getKind() == AttributeList::AT_AddressSpace) {
+ for (const ParsedAttr &AL : Attrs) {
+ if (AL.getKind() == ParsedAttr::AT_AddressSpace) {
DASTL.setAttrNameLoc(AL.getLoc());
DASTL.setAttrExprOperand(AL.getArgAsExpr(0));
DASTL.setAttrOperandParensRange(SourceRange());
@@ -5755,7 +5747,7 @@
/// specified type. The attribute contains 1 argument, the id of the address
/// space for the type.
static void HandleAddressSpaceTypeAttribute(QualType &Type,
- const AttributeList &Attr, Sema &S){
+ const ParsedAttr &Attr, Sema &S) {
// ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "A function type shall not be
// qualified by an address-space qualifier."
if (Type->isFunctionType()) {
@@ -5765,7 +5757,7 @@
}
LangAS ASIdx;
- if (Attr.getKind() == AttributeList::AT_AddressSpace) {
+ if (Attr.getKind() == ParsedAttr::AT_AddressSpace) {
// Check the attribute arguments.
if (Attr.getNumArgs() != 1) {
@@ -5804,15 +5796,15 @@
} else {
// The keyword-based type attributes imply which address space to use.
switch (Attr.getKind()) {
- case AttributeList::AT_OpenCLGlobalAddressSpace:
+ case ParsedAttr::AT_OpenCLGlobalAddressSpace:
ASIdx = LangAS::opencl_global; break;
- case AttributeList::AT_OpenCLLocalAddressSpace:
+ case ParsedAttr::AT_OpenCLLocalAddressSpace:
ASIdx = LangAS::opencl_local; break;
- case AttributeList::AT_OpenCLConstantAddressSpace:
+ case ParsedAttr::AT_OpenCLConstantAddressSpace:
ASIdx = LangAS::opencl_constant; break;
- case AttributeList::AT_OpenCLGenericAddressSpace:
+ case ParsedAttr::AT_OpenCLGenericAddressSpace:
ASIdx = LangAS::opencl_generic; break;
- case AttributeList::AT_OpenCLPrivateAddressSpace:
+ case ParsedAttr::AT_OpenCLPrivateAddressSpace:
ASIdx = LangAS::opencl_private; break;
default:
llvm_unreachable("Invalid address space");
@@ -5872,8 +5864,7 @@
///
/// Returns 'true' if the attribute was handled.
static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state,
- AttributeList &attr,
- QualType &type) {
+ ParsedAttr &attr, QualType &type) {
bool NonObjCPointer = false;
if (!type->isDependentType() && !type->isUndeducedType()) {
@@ -6058,8 +6049,7 @@
/// attribute on the specified type. Returns true to indicate that
/// the attribute was handled, false to indicate that the type does
/// not permit the attribute.
-static bool handleObjCGCTypeAttr(TypeProcessingState &state,
- AttributeList &attr,
+static bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
QualType &type) {
Sema &S = state.getSema();
@@ -6251,11 +6241,10 @@
} // end anonymous namespace
static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &State,
- AttributeList &Attr,
- QualType &Type) {
+ ParsedAttr &Attr, QualType &Type) {
Sema &S = State.getSema();
- AttributeList::Kind Kind = Attr.getKind();
+ ParsedAttr::Kind Kind = Attr.getKind();
QualType Desugared = Type;
const AttributedType *AT = dyn_cast<AttributedType>(Type);
while (AT) {
@@ -6272,16 +6261,16 @@
// You cannot have both __sptr and __uptr on the same type, nor can you
// have __ptr32 and __ptr64.
if ((CurAttrKind == AttributedType::attr_ptr32 &&
- Kind == AttributeList::AT_Ptr64) ||
+ Kind == ParsedAttr::AT_Ptr64) ||
(CurAttrKind == AttributedType::attr_ptr64 &&
- Kind == AttributeList::AT_Ptr32)) {
+ Kind == ParsedAttr::AT_Ptr32)) {
S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
<< "'__ptr32'" << "'__ptr64'";
return true;
} else if ((CurAttrKind == AttributedType::attr_sptr &&
- Kind == AttributeList::AT_UPtr) ||
+ Kind == ParsedAttr::AT_UPtr) ||
(CurAttrKind == AttributedType::attr_uptr &&
- Kind == AttributeList::AT_SPtr)) {
+ Kind == ParsedAttr::AT_SPtr)) {
S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible)
<< "'__sptr'" << "'__uptr'";
return true;
@@ -6306,10 +6295,18 @@
AttributedType::Kind TAK;
switch (Kind) {
default: llvm_unreachable("Unknown attribute kind");
- case AttributeList::AT_Ptr32: TAK = AttributedType::attr_ptr32; break;
- case AttributeList::AT_Ptr64: TAK = AttributedType::attr_ptr64; break;
- case AttributeList::AT_SPtr: TAK = AttributedType::attr_sptr; break;
- case AttributeList::AT_UPtr: TAK = AttributedType::attr_uptr; break;
+ case ParsedAttr::AT_Ptr32:
+ TAK = AttributedType::attr_ptr32;
+ break;
+ case ParsedAttr::AT_Ptr64:
+ TAK = AttributedType::attr_ptr64;
+ break;
+ case ParsedAttr::AT_SPtr:
+ TAK = AttributedType::attr_sptr;
+ break;
+ case ParsedAttr::AT_UPtr:
+ TAK = AttributedType::attr_uptr;
+ break;
}
Type = S.Context.getAttributedType(TAK, Type, Type);
@@ -6460,15 +6457,15 @@
}
/// Map a nullability attribute kind to a nullability kind.
-static NullabilityKind mapNullabilityAttrKind(AttributeList::Kind kind) {
+static NullabilityKind mapNullabilityAttrKind(ParsedAttr::Kind kind) {
switch (kind) {
- case AttributeList::AT_TypeNonNull:
+ case ParsedAttr::AT_TypeNonNull:
return NullabilityKind::NonNull;
- case AttributeList::AT_TypeNullable:
+ case ParsedAttr::AT_TypeNullable:
return NullabilityKind::Nullable;
- case AttributeList::AT_TypeNullUnspecified:
+ case ParsedAttr::AT_TypeNullUnspecified:
return NullabilityKind::Unspecified;
default:
@@ -6483,8 +6480,7 @@
/// \returns true if the nullability annotation was distributed, false
/// otherwise.
static bool distributeNullabilityTypeAttr(TypeProcessingState &state,
- QualType type,
- AttributeList &attr) {
+ QualType type, ParsedAttr &attr) {
Declarator &declarator = state.getDeclarator();
/// Attempt to move the attribute to the specified chunk.
@@ -6564,28 +6560,28 @@
return false;
}
-static AttributedType::Kind getCCTypeAttrKind(AttributeList &Attr) {
+static AttributedType::Kind getCCTypeAttrKind(ParsedAttr &Attr) {
assert(!Attr.isInvalid());
switch (Attr.getKind()) {
default:
llvm_unreachable("not a calling convention attribute");
- case AttributeList::AT_CDecl:
+ case ParsedAttr::AT_CDecl:
return AttributedType::attr_cdecl;
- case AttributeList::AT_FastCall:
+ case ParsedAttr::AT_FastCall:
return AttributedType::attr_fastcall;
- case AttributeList::AT_StdCall:
+ case ParsedAttr::AT_StdCall:
return AttributedType::attr_stdcall;
- case AttributeList::AT_ThisCall:
+ case ParsedAttr::AT_ThisCall:
return AttributedType::attr_thiscall;
- case AttributeList::AT_RegCall:
+ case ParsedAttr::AT_RegCall:
return AttributedType::attr_regcall;
- case AttributeList::AT_Pascal:
+ case ParsedAttr::AT_Pascal:
return AttributedType::attr_pascal;
- case AttributeList::AT_SwiftCall:
+ case ParsedAttr::AT_SwiftCall:
return AttributedType::attr_swiftcall;
- case AttributeList::AT_VectorCall:
+ case ParsedAttr::AT_VectorCall:
return AttributedType::attr_vectorcall;
- case AttributeList::AT_Pcs: {
+ case ParsedAttr::AT_Pcs: {
// The attribute may have had a fixit applied where we treated an
// identifier as a string literal. The contents of the string are valid,
// but the form may not be.
@@ -6598,15 +6594,15 @@
.Case("aapcs", AttributedType::attr_pcs)
.Case("aapcs-vfp", AttributedType::attr_pcs_vfp);
}
- case AttributeList::AT_IntelOclBicc:
+ case ParsedAttr::AT_IntelOclBicc:
return AttributedType::attr_inteloclbicc;
- case AttributeList::AT_MSABI:
+ case ParsedAttr::AT_MSABI:
return AttributedType::attr_ms_abi;
- case AttributeList::AT_SysVABI:
+ case ParsedAttr::AT_SysVABI:
return AttributedType::attr_sysv_abi;
- case AttributeList::AT_PreserveMost:
+ case ParsedAttr::AT_PreserveMost:
return AttributedType::attr_preserve_most;
- case AttributeList::AT_PreserveAll:
+ case ParsedAttr::AT_PreserveAll:
return AttributedType::attr_preserve_all;
}
llvm_unreachable("unexpected attribute kind!");
@@ -6614,14 +6610,13 @@
/// Process an individual function attribute. Returns true to
/// indicate that the attribute was handled, false if it wasn't.
-static bool handleFunctionTypeAttr(TypeProcessingState &state,
- AttributeList &attr,
+static bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr,
QualType &type) {
Sema &S = state.getSema();
FunctionTypeUnwrapper unwrapped(S, type);
- if (attr.getKind() == AttributeList::AT_NoReturn) {
+ if (attr.getKind() == ParsedAttr::AT_NoReturn) {
if (S.CheckAttrNoArgs(attr))
return true;
@@ -6637,7 +6632,7 @@
// ns_returns_retained is not always a type attribute, but if we got
// here, we're treating it as one right now.
- if (attr.getKind() == AttributeList::AT_NSReturnsRetained) {
+ if (attr.getKind() == ParsedAttr::AT_NSReturnsRetained) {
if (attr.getNumArgs()) return true;
// Delay if this is not a function type.
@@ -6661,7 +6656,7 @@
return true;
}
- if (attr.getKind() == AttributeList::AT_AnyX86NoCallerSavedRegisters) {
+ if (attr.getKind() == ParsedAttr::AT_AnyX86NoCallerSavedRegisters) {
if (S.CheckAttrTarget(attr) || S.CheckAttrNoArgs(attr))
return true;
@@ -6675,7 +6670,7 @@
return true;
}
- if (attr.getKind() == AttributeList::AT_AnyX86NoCfCheck) {
+ if (attr.getKind() == ParsedAttr::AT_AnyX86NoCfCheck) {
if (!S.getLangOpts().CFProtectionBranch) {
S.Diag(attr.getLoc(), diag::warn_nocf_check_attribute_ignored);
attr.setInvalid();
@@ -6696,7 +6691,7 @@
return true;
}
- if (attr.getKind() == AttributeList::AT_Regparm) {
+ if (attr.getKind() == ParsedAttr::AT_Regparm) {
unsigned value;
if (S.CheckRegparmAttr(attr, value))
return true;
@@ -6853,7 +6848,7 @@
/// The raw attribute should contain precisely 1 argument, the vector size for
/// the variable, measured in bytes. If curType and rawAttr are well formed,
/// this routine will return a new vector type.
-static void HandleVectorSizeAttr(QualType& CurType, const AttributeList &Attr,
+static void HandleVectorSizeAttr(QualType &CurType, const ParsedAttr &Attr,
Sema &S) {
// Check the attribute arguments.
if (Attr.getNumArgs() != 1) {
@@ -6912,8 +6907,7 @@
/// Process the OpenCL-like ext_vector_type attribute when it occurs on
/// a type.
-static void HandleExtVectorTypeAttr(QualType &CurType,
- const AttributeList &Attr,
+static void HandleExtVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr,
Sema &S) {
// check the attribute arguments.
if (Attr.getNumArgs() != 1) {
@@ -7002,9 +6996,8 @@
/// the argument to these Neon attributes is the number of vector elements,
/// not the vector size in bytes. The vector width and element type must
/// match one of the standard Neon vector types.
-static void HandleNeonVectorTypeAttr(QualType& CurType,
- const AttributeList &Attr, Sema &S,
- VectorType::VectorKind VecKind) {
+static void HandleNeonVectorTypeAttr(QualType &CurType, const ParsedAttr &Attr,
+ Sema &S, VectorType::VectorKind VecKind) {
// Target must have NEON
if (!S.Context.getTargetInfo().hasFeature("neon")) {
S.Diag(Attr.getLoc(), diag::err_attribute_unsupported) << Attr.getName();
@@ -7050,7 +7043,7 @@
}
/// Handle OpenCL Access Qualifier Attribute.
-static void HandleOpenCLAccessAttr(QualType &CurType, const AttributeList &Attr,
+static void HandleOpenCLAccessAttr(QualType &CurType, const ParsedAttr &Attr,
Sema &S) {
// OpenCL v2.0 s6.6 - Access qualifier can be used only for image and pipe type.
if (!(CurType->isImageType() || CurType->isPipeType())) {
@@ -7183,7 +7176,7 @@
// sure we visit every element once. Copy the attributes list, and iterate
// over that.
ParsedAttributesView AttrsCopy{attrs};
- for (AttributeList &attr : AttrsCopy) {
+ for (ParsedAttr &attr : AttrsCopy) {
// Skip attributes that were marked to be invalid.
if (attr.isInvalid())
@@ -7224,27 +7217,27 @@
}
break;
- case AttributeList::UnknownAttribute:
+ case ParsedAttr::UnknownAttribute:
if (attr.isCXX11Attribute() && TAL == TAL_DeclChunk)
state.getSema().Diag(attr.getLoc(),
diag::warn_unknown_attribute_ignored)
<< attr.getName();
break;
- case AttributeList::IgnoredAttribute:
+ case ParsedAttr::IgnoredAttribute:
break;
- case AttributeList::AT_MayAlias:
+ case ParsedAttr::AT_MayAlias:
// FIXME: This attribute needs to actually be handled, but if we ignore
// it it breaks large amounts of Linux software.
attr.setUsedAsTypeAttr();
break;
- case AttributeList::AT_OpenCLPrivateAddressSpace:
- case AttributeList::AT_OpenCLGlobalAddressSpace:
- case AttributeList::AT_OpenCLLocalAddressSpace:
- case AttributeList::AT_OpenCLConstantAddressSpace:
- case AttributeList::AT_OpenCLGenericAddressSpace:
- case AttributeList::AT_AddressSpace:
+ case ParsedAttr::AT_OpenCLPrivateAddressSpace:
+ case ParsedAttr::AT_OpenCLGlobalAddressSpace:
+ case ParsedAttr::AT_OpenCLLocalAddressSpace:
+ case ParsedAttr::AT_OpenCLConstantAddressSpace:
+ case ParsedAttr::AT_OpenCLGenericAddressSpace:
+ case ParsedAttr::AT_AddressSpace:
HandleAddressSpaceTypeAttribute(type, attr, state.getSema());
attr.setUsedAsTypeAttr();
break;
@@ -7253,25 +7246,25 @@
distributeObjCPointerTypeAttr(state, attr, type);
attr.setUsedAsTypeAttr();
break;
- case AttributeList::AT_VectorSize:
+ case ParsedAttr::AT_VectorSize:
HandleVectorSizeAttr(type, attr, state.getSema());
attr.setUsedAsTypeAttr();
break;
- case AttributeList::AT_ExtVectorType:
+ case ParsedAttr::AT_ExtVectorType:
HandleExtVectorTypeAttr(type, attr, state.getSema());
attr.setUsedAsTypeAttr();
break;
- case AttributeList::AT_NeonVectorType:
+ case ParsedAttr::AT_NeonVectorType:
HandleNeonVectorTypeAttr(type, attr, state.getSema(),
VectorType::NeonVector);
attr.setUsedAsTypeAttr();
break;
- case AttributeList::AT_NeonPolyVectorType:
+ case ParsedAttr::AT_NeonPolyVectorType:
HandleNeonVectorTypeAttr(type, attr, state.getSema(),
VectorType::NeonPolyVector);
attr.setUsedAsTypeAttr();
break;
- case AttributeList::AT_OpenCLAccess:
+ case ParsedAttr::AT_OpenCLAccess:
HandleOpenCLAccessAttr(type, attr, state.getSema());
attr.setUsedAsTypeAttr();
break;
@@ -7310,7 +7303,7 @@
}
break;
- case AttributeList::AT_ObjCKindOf:
+ case ParsedAttr::AT_ObjCKindOf:
// '__kindof' must be part of the decl-specifiers.
switch (TAL) {
case TAL_DeclSpec: