aboutsummaryrefslogtreecommitdiff
path: root/clang/lib/ASTMatchers
diff options
context:
space:
mode:
Diffstat (limited to 'clang/lib/ASTMatchers')
-rw-r--r--clang/lib/ASTMatchers/ASTMatchFinder.cpp14
-rw-r--r--clang/lib/ASTMatchers/ASTMatchersInternal.cpp17
-rw-r--r--clang/lib/ASTMatchers/Dynamic/Marshallers.cpp61
-rw-r--r--clang/lib/ASTMatchers/Dynamic/Marshallers.h74
-rw-r--r--clang/lib/ASTMatchers/Dynamic/Parser.cpp23
-rw-r--r--clang/lib/ASTMatchers/Dynamic/Registry.cpp14
-rw-r--r--clang/lib/ASTMatchers/Dynamic/VariantValue.cpp33
7 files changed, 116 insertions, 120 deletions
diff --git a/clang/lib/ASTMatchers/ASTMatchFinder.cpp b/clang/lib/ASTMatchers/ASTMatchFinder.cpp
index ac8e4eccad8e..a27fac62bdef 100644
--- a/clang/lib/ASTMatchers/ASTMatchFinder.cpp
+++ b/clang/lib/ASTMatchers/ASTMatchFinder.cpp
@@ -779,7 +779,7 @@ private:
#define IMPL(Index) \
template <typename NodeType> \
- typename std::enable_if_t< \
+ std::enable_if_t< \
llvm::is_one_of<const NodeType *, CMD_TYPES_##Index>::value> \
SetCallbackAndRawNode(const MatchCallback *CB, const NodeType &N) { \
assertEmpty(); \
@@ -788,8 +788,8 @@ private:
} \
\
template <typename T> \
- typename std::enable_if_t< \
- llvm::is_one_of<const T *, CMD_TYPES_##Index>::value, const T *> \
+ std::enable_if_t<llvm::is_one_of<const T *, CMD_TYPES_##Index>::value, \
+ const T *> \
getNode() const { \
assertHoldsState(); \
return Callback.getInt() == (Index) ? Node##Index.dyn_cast<const T *>() \
@@ -1562,7 +1562,7 @@ MatchFinder::~MatchFinder() {}
void MatchFinder::addMatcher(const DeclarationMatcher &NodeMatch,
MatchCallback *Action) {
- llvm::Optional<TraversalKind> TK;
+ std::optional<TraversalKind> TK;
if (Action)
TK = Action->getCheckTraversalKind();
if (TK)
@@ -1580,7 +1580,7 @@ void MatchFinder::addMatcher(const TypeMatcher &NodeMatch,
void MatchFinder::addMatcher(const StatementMatcher &NodeMatch,
MatchCallback *Action) {
- llvm::Optional<TraversalKind> TK;
+ std::optional<TraversalKind> TK;
if (Action)
TK = Action->getCheckTraversalKind();
if (TK)
@@ -1685,9 +1685,9 @@ void MatchFinder::registerTestCallbackAfterParsing(
StringRef MatchFinder::MatchCallback::getID() const { return "<unknown>"; }
-llvm::Optional<TraversalKind>
+std::optional<TraversalKind>
MatchFinder::MatchCallback::getCheckTraversalKind() const {
- return llvm::None;
+ return std::nullopt;
}
} // end namespace ast_matchers
diff --git a/clang/lib/ASTMatchers/ASTMatchersInternal.cpp b/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
index 4c438f9e4879..f1f73fc42075 100644
--- a/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
+++ b/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
@@ -22,7 +22,6 @@
#include "clang/Lex/Lexer.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/IntrusiveRefCntPtr.h"
-#include "llvm/ADT/None.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
@@ -35,6 +34,7 @@
#include <algorithm>
#include <cassert>
#include <cstddef>
+#include <optional>
#include <string>
#include <utility>
#include <vector>
@@ -140,7 +140,7 @@ public:
return Result;
}
- llvm::Optional<clang::TraversalKind> TraversalKind() const override {
+ std::optional<clang::TraversalKind> TraversalKind() const override {
return InnerMatcher->TraversalKind();
}
@@ -176,7 +176,7 @@ public:
return this->InnerMatcher->dynMatches(DynNode, Finder, Builder);
}
- llvm::Optional<clang::TraversalKind> TraversalKind() const override {
+ std::optional<clang::TraversalKind> TraversalKind() const override {
return TK;
}
@@ -339,8 +339,9 @@ bool DynTypedMatcher::matchesNoKindCheck(const DynTypedNode &DynNode,
return false;
}
-llvm::Optional<DynTypedMatcher> DynTypedMatcher::tryBind(StringRef ID) const {
- if (!AllowBind) return llvm::None;
+std::optional<DynTypedMatcher> DynTypedMatcher::tryBind(StringRef ID) const {
+ if (!AllowBind)
+ return std::nullopt;
auto Result = *this;
Result.Implementation =
new IdDynMatcher(ID, std::move(Result.Implementation));
@@ -685,7 +686,7 @@ static bool isTokenAtLoc(const SourceManager &SM, const LangOptions &LangOpts,
return !Invalid && Text == TokenText;
}
-llvm::Optional<SourceLocation>
+std::optional<SourceLocation>
getExpansionLocOfMacro(StringRef MacroName, SourceLocation Loc,
const ASTContext &Context) {
auto &SM = Context.getSourceManager();
@@ -696,14 +697,14 @@ getExpansionLocOfMacro(StringRef MacroName, SourceLocation Loc,
if (Expansion.isMacroArgExpansion())
// Check macro argument for an expansion of the given macro. For example,
// `F(G(3))`, where `MacroName` is `G`.
- if (llvm::Optional<SourceLocation> ArgLoc = getExpansionLocOfMacro(
+ if (std::optional<SourceLocation> ArgLoc = getExpansionLocOfMacro(
MacroName, Expansion.getSpellingLoc(), Context))
return ArgLoc;
Loc = Expansion.getExpansionLocStart();
if (isTokenAtLoc(SM, LangOpts, MacroName, Loc))
return Loc;
}
- return llvm::None;
+ return std::nullopt;
}
std::shared_ptr<llvm::Regex> createAndVerifyRegex(StringRef Regex,
diff --git a/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp b/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp
index 70b5953fe969..cf9ae7c974a6 100644
--- a/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp
@@ -8,12 +8,12 @@
#include "Marshallers.h"
#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Regex.h"
+#include <optional>
#include <string>
-static llvm::Optional<std::string>
+static std::optional<std::string>
getBestGuess(llvm::StringRef Search, llvm::ArrayRef<llvm::StringRef> Allowed,
llvm::StringRef DropPrefix = "", unsigned MaxEditDistance = 3) {
if (MaxEditDistance != ~0U)
@@ -56,10 +56,10 @@ getBestGuess(llvm::StringRef Search, llvm::ArrayRef<llvm::StringRef> Allowed,
if (!Res.empty())
return Res.str();
}
- return llvm::None;
+ return std::nullopt;
}
-llvm::Optional<std::string>
+std::optional<std::string>
clang::ast_matchers::dynamic::internal::ArgTypeTraits<
clang::attr::Kind>::getBestGuess(const VariantValue &Value) {
static constexpr llvm::StringRef Allowed[] = {
@@ -67,12 +67,11 @@ clang::ast_matchers::dynamic::internal::ArgTypeTraits<
#include "clang/Basic/AttrList.inc"
};
if (Value.isString())
- return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed),
- "attr::");
- return llvm::None;
+ return ::getBestGuess(Value.getString(), llvm::ArrayRef(Allowed), "attr::");
+ return std::nullopt;
}
-llvm::Optional<std::string>
+std::optional<std::string>
clang::ast_matchers::dynamic::internal::ArgTypeTraits<
clang::CastKind>::getBestGuess(const VariantValue &Value) {
static constexpr llvm::StringRef Allowed[] = {
@@ -80,12 +79,11 @@ clang::ast_matchers::dynamic::internal::ArgTypeTraits<
#include "clang/AST/OperationKinds.def"
};
if (Value.isString())
- return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed),
- "CK_");
- return llvm::None;
+ return ::getBestGuess(Value.getString(), llvm::ArrayRef(Allowed), "CK_");
+ return std::nullopt;
}
-llvm::Optional<std::string>
+std::optional<std::string>
clang::ast_matchers::dynamic::internal::ArgTypeTraits<
clang::OpenMPClauseKind>::getBestGuess(const VariantValue &Value) {
static constexpr llvm::StringRef Allowed[] = {
@@ -94,12 +92,11 @@ clang::ast_matchers::dynamic::internal::ArgTypeTraits<
#include "llvm/Frontend/OpenMP/OMP.inc"
};
if (Value.isString())
- return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed),
- "OMPC_");
- return llvm::None;
+ return ::getBestGuess(Value.getString(), llvm::ArrayRef(Allowed), "OMPC_");
+ return std::nullopt;
}
-llvm::Optional<std::string>
+std::optional<std::string>
clang::ast_matchers::dynamic::internal::ArgTypeTraits<
clang::UnaryExprOrTypeTrait>::getBestGuess(const VariantValue &Value) {
static constexpr llvm::StringRef Allowed[] = {
@@ -108,9 +105,8 @@ clang::ast_matchers::dynamic::internal::ArgTypeTraits<
#include "clang/Basic/TokenKinds.def"
};
if (Value.isString())
- return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed),
- "UETT_");
- return llvm::None;
+ return ::getBestGuess(Value.getString(), llvm::ArrayRef(Allowed), "UETT_");
+ return std::nullopt;
}
static constexpr std::pair<llvm::StringRef, llvm::Regex::RegexFlags>
@@ -121,55 +117,54 @@ static constexpr std::pair<llvm::StringRef, llvm::Regex::RegexFlags>
{"BasicRegex", llvm::Regex::RegexFlags::BasicRegex},
};
-static llvm::Optional<llvm::Regex::RegexFlags>
+static std::optional<llvm::Regex::RegexFlags>
getRegexFlag(llvm::StringRef Flag) {
for (const auto &StringFlag : RegexMap) {
if (Flag == StringFlag.first)
return StringFlag.second;
}
- return llvm::None;
+ return std::nullopt;
}
-static llvm::Optional<llvm::StringRef>
-getCloseRegexMatch(llvm::StringRef Flag) {
+static std::optional<llvm::StringRef> getCloseRegexMatch(llvm::StringRef Flag) {
for (const auto &StringFlag : RegexMap) {
if (Flag.edit_distance(StringFlag.first) < 3)
return StringFlag.first;
}
- return llvm::None;
+ return std::nullopt;
}
-llvm::Optional<llvm::Regex::RegexFlags>
+std::optional<llvm::Regex::RegexFlags>
clang::ast_matchers::dynamic::internal::ArgTypeTraits<
llvm::Regex::RegexFlags>::getFlags(llvm::StringRef Flags) {
- llvm::Optional<llvm::Regex::RegexFlags> Flag;
+ std::optional<llvm::Regex::RegexFlags> Flag;
SmallVector<StringRef, 4> Split;
Flags.split(Split, '|', -1, false);
for (StringRef OrFlag : Split) {
- if (llvm::Optional<llvm::Regex::RegexFlags> NextFlag =
+ if (std::optional<llvm::Regex::RegexFlags> NextFlag =
getRegexFlag(OrFlag.trim()))
Flag = Flag.value_or(llvm::Regex::NoFlags) | *NextFlag;
else
- return None;
+ return std::nullopt;
}
return Flag;
}
-llvm::Optional<std::string>
+std::optional<std::string>
clang::ast_matchers::dynamic::internal::ArgTypeTraits<
llvm::Regex::RegexFlags>::getBestGuess(const VariantValue &Value) {
if (!Value.isString())
- return llvm::None;
+ return std::nullopt;
SmallVector<StringRef, 4> Split;
llvm::StringRef(Value.getString()).split(Split, '|', -1, false);
for (llvm::StringRef &Flag : Split) {
- if (llvm::Optional<llvm::StringRef> BestGuess =
+ if (std::optional<llvm::StringRef> BestGuess =
getCloseRegexMatch(Flag.trim()))
Flag = *BestGuess;
else
- return None;
+ return std::nullopt;
}
if (Split.empty())
- return None;
+ return std::nullopt;
return llvm::join(Split, " | ");
}
diff --git a/clang/lib/ASTMatchers/Dynamic/Marshallers.h b/clang/lib/ASTMatchers/Dynamic/Marshallers.h
index bab36e5db47e..1b099ec3a314 100644
--- a/clang/lib/ASTMatchers/Dynamic/Marshallers.h
+++ b/clang/lib/ASTMatchers/Dynamic/Marshallers.h
@@ -29,8 +29,6 @@
#include "clang/Basic/OpenMPKinds.h"
#include "clang/Basic/TypeTraits.h"
#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/None.h"
-#include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
@@ -41,6 +39,7 @@
#include <iterator>
#include <limits>
#include <memory>
+#include <optional>
#include <string>
#include <utility>
#include <vector>
@@ -71,8 +70,8 @@ template <> struct ArgTypeTraits<std::string> {
return ArgKind(ArgKind::AK_String);
}
- static llvm::Optional<std::string> getBestGuess(const VariantValue &) {
- return llvm::None;
+ static std::optional<std::string> getBestGuess(const VariantValue &) {
+ return std::nullopt;
}
};
@@ -96,8 +95,8 @@ template <class T> struct ArgTypeTraits<ast_matchers::internal::Matcher<T>> {
return ArgKind::MakeMatcherArg(ASTNodeKind::getFromNodeKind<T>());
}
- static llvm::Optional<std::string> getBestGuess(const VariantValue &) {
- return llvm::None;
+ static std::optional<std::string> getBestGuess(const VariantValue &) {
+ return std::nullopt;
}
};
@@ -115,8 +114,8 @@ template <> struct ArgTypeTraits<bool> {
return ArgKind(ArgKind::AK_Boolean);
}
- static llvm::Optional<std::string> getBestGuess(const VariantValue &) {
- return llvm::None;
+ static std::optional<std::string> getBestGuess(const VariantValue &) {
+ return std::nullopt;
}
};
@@ -134,8 +133,8 @@ template <> struct ArgTypeTraits<double> {
return ArgKind(ArgKind::AK_Double);
}
- static llvm::Optional<std::string> getBestGuess(const VariantValue &) {
- return llvm::None;
+ static std::optional<std::string> getBestGuess(const VariantValue &) {
+ return std::nullopt;
}
};
@@ -153,20 +152,20 @@ template <> struct ArgTypeTraits<unsigned> {
return ArgKind(ArgKind::AK_Unsigned);
}
- static llvm::Optional<std::string> getBestGuess(const VariantValue &) {
- return llvm::None;
+ static std::optional<std::string> getBestGuess(const VariantValue &) {
+ return std::nullopt;
}
};
template <> struct ArgTypeTraits<attr::Kind> {
private:
- static Optional<attr::Kind> getAttrKind(llvm::StringRef AttrKind) {
+ static std::optional<attr::Kind> getAttrKind(llvm::StringRef AttrKind) {
if (!AttrKind.consume_front("attr::"))
- return llvm::None;
- return llvm::StringSwitch<Optional<attr::Kind>>(AttrKind)
+ return std::nullopt;
+ return llvm::StringSwitch<std::optional<attr::Kind>>(AttrKind)
#define ATTR(X) .Case(#X, attr::X)
#include "clang/Basic/AttrList.inc"
- .Default(llvm::None);
+ .Default(std::nullopt);
}
public:
@@ -185,18 +184,18 @@ public:
return ArgKind(ArgKind::AK_String);
}
- static llvm::Optional<std::string> getBestGuess(const VariantValue &Value);
+ static std::optional<std::string> getBestGuess(const VariantValue &Value);
};
template <> struct ArgTypeTraits<CastKind> {
private:
- static Optional<CastKind> getCastKind(llvm::StringRef AttrKind) {
+ static std::optional<CastKind> getCastKind(llvm::StringRef AttrKind) {
if (!AttrKind.consume_front("CK_"))
- return llvm::None;
- return llvm::StringSwitch<Optional<CastKind>>(AttrKind)
+ return std::nullopt;
+ return llvm::StringSwitch<std::optional<CastKind>>(AttrKind)
#define CAST_OPERATION(Name) .Case(#Name, CK_##Name)
#include "clang/AST/OperationKinds.def"
- .Default(llvm::None);
+ .Default(std::nullopt);
}
public:
@@ -215,12 +214,12 @@ public:
return ArgKind(ArgKind::AK_String);
}
- static llvm::Optional<std::string> getBestGuess(const VariantValue &Value);
+ static std::optional<std::string> getBestGuess(const VariantValue &Value);
};
template <> struct ArgTypeTraits<llvm::Regex::RegexFlags> {
private:
- static Optional<llvm::Regex::RegexFlags> getFlags(llvm::StringRef Flags);
+ static std::optional<llvm::Regex::RegexFlags> getFlags(llvm::StringRef Flags);
public:
static bool hasCorrectType(const VariantValue &Value) {
@@ -236,17 +235,18 @@ public:
static ArgKind getKind() { return ArgKind(ArgKind::AK_String); }
- static llvm::Optional<std::string> getBestGuess(const VariantValue &Value);
+ static std::optional<std::string> getBestGuess(const VariantValue &Value);
};
template <> struct ArgTypeTraits<OpenMPClauseKind> {
private:
- static Optional<OpenMPClauseKind> getClauseKind(llvm::StringRef ClauseKind) {
- return llvm::StringSwitch<Optional<OpenMPClauseKind>>(ClauseKind)
+ static std::optional<OpenMPClauseKind>
+ getClauseKind(llvm::StringRef ClauseKind) {
+ return llvm::StringSwitch<std::optional<OpenMPClauseKind>>(ClauseKind)
#define GEN_CLANG_CLAUSE_CLASS
#define CLAUSE_CLASS(Enum, Str, Class) .Case(#Enum, llvm::omp::Clause::Enum)
#include "llvm/Frontend/OpenMP/OMP.inc"
- .Default(llvm::None);
+ .Default(std::nullopt);
}
public:
@@ -263,21 +263,21 @@ public:
static ArgKind getKind() { return ArgKind(ArgKind::AK_String); }
- static llvm::Optional<std::string> getBestGuess(const VariantValue &Value);
+ static std::optional<std::string> getBestGuess(const VariantValue &Value);
};
template <> struct ArgTypeTraits<UnaryExprOrTypeTrait> {
private:
- static Optional<UnaryExprOrTypeTrait>
+ static std::optional<UnaryExprOrTypeTrait>
getUnaryOrTypeTraitKind(llvm::StringRef ClauseKind) {
if (!ClauseKind.consume_front("UETT_"))
- return llvm::None;
- return llvm::StringSwitch<Optional<UnaryExprOrTypeTrait>>(ClauseKind)
+ return std::nullopt;
+ return llvm::StringSwitch<std::optional<UnaryExprOrTypeTrait>>(ClauseKind)
#define UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) .Case(#Name, UETT_##Name)
#define CXX11_UNARY_EXPR_OR_TYPE_TRAIT(Spelling, Name, Key) \
.Case(#Name, UETT_##Name)
#include "clang/Basic/TokenKinds.def"
- .Default(llvm::None);
+ .Default(std::nullopt);
}
public:
@@ -294,7 +294,7 @@ public:
static ArgKind getKind() { return ArgKind(ArgKind::AK_String); }
- static llvm::Optional<std::string> getBestGuess(const VariantValue &Value);
+ static std::optional<std::string> getBestGuess(const VariantValue &Value);
};
/// Matcher descriptor interface.
@@ -508,7 +508,7 @@ variadicMatcherDescriptor(StringRef MatcherName, SourceRange NameRange,
return {};
}
if (!ArgTraits::hasCorrectValue(Value)) {
- if (llvm::Optional<std::string> BestGuess =
+ if (std::optional<std::string> BestGuess =
ArgTraits::getBestGuess(Value)) {
Error->addError(Arg.Range, Error->ET_RegistryUnknownEnumWithReplace)
<< i + 1 << Value.getString() << *BestGuess;
@@ -635,7 +635,7 @@ private:
return VariantMatcher(); \
} \
if (!ArgTypeTraits<type>::hasCorrectValue(Args[index].Value)) { \
- if (llvm::Optional<std::string> BestGuess = \
+ if (std::optional<std::string> BestGuess = \
ArgTypeTraits<type>::getBestGuess(Args[index].Value)) { \
Error->addError(Args[index].Range, \
Error->ET_RegistryUnknownEnumWithReplace) \
@@ -845,7 +845,7 @@ public:
}
if (!ArgTypeTraits<llvm::Regex::RegexFlags>::hasCorrectValue(
Args[1].Value)) {
- if (llvm::Optional<std::string> BestGuess =
+ if (std::optional<std::string> BestGuess =
ArgTypeTraits<llvm::Regex::RegexFlags>::getBestGuess(
Args[1].Value)) {
Error->addError(Args[1].Range, Error->ET_RegistryUnknownEnumWithReplace)
@@ -1060,7 +1060,7 @@ makeMatcherAutoMarshall(ReturnType (*Func)(), StringRef MatcherName) {
BuildReturnTypeVector<ReturnType>::build(RetTypes);
return std::make_unique<FixedArgCountMatcherDescriptor>(
matcherMarshall0<ReturnType>, reinterpret_cast<void (*)()>(Func),
- MatcherName, RetTypes, None);
+ MatcherName, RetTypes, std::nullopt);
}
/// 1-arg overload
diff --git a/clang/lib/ASTMatchers/Dynamic/Parser.cpp b/clang/lib/ASTMatchers/Dynamic/Parser.cpp
index 6470df27e6e2..33a10fe838a6 100644
--- a/clang/lib/ASTMatchers/Dynamic/Parser.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/Parser.cpp
@@ -16,7 +16,6 @@
#include "clang/ASTMatchers/Dynamic/Diagnostics.h"
#include "clang/ASTMatchers/Dynamic/Registry.h"
#include "clang/Basic/CharInfo.h"
-#include "llvm/ADT/Optional.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/ManagedStatic.h"
@@ -25,6 +24,7 @@
#include <cerrno>
#include <cstddef>
#include <cstdlib>
+#include <optional>
#include <string>
#include <utility>
#include <vector>
@@ -395,10 +395,10 @@ bool Parser::parseIdentifierPrefixImpl(VariantValue *Value) {
return false;
assert(NamedValue.isMatcher());
- llvm::Optional<DynTypedMatcher> Result =
+ std::optional<DynTypedMatcher> Result =
NamedValue.getMatcher().getSingleMatcher();
if (Result) {
- llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
+ std::optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
if (Bound) {
*Value = VariantMatcher::SingleMatcher(*Bound);
return true;
@@ -438,7 +438,7 @@ bool Parser::parseIdentifierPrefixImpl(VariantValue *Value) {
return false;
}
- llvm::Optional<MatcherCtor> Ctor = S->lookupMatcherCtor(NameToken.Text);
+ std::optional<MatcherCtor> Ctor = S->lookupMatcherCtor(NameToken.Text);
// Parse as a matcher expression.
return parseMatcherExpressionImpl(NameToken, OpenToken, Ctor, Value);
@@ -517,7 +517,7 @@ bool Parser::parseMatcherBuilder(MatcherCtor Ctor, const TokenInfo &NameToken,
ArgValue.Text = NodeMatcherToken.Text;
ArgValue.Range = NodeMatcherToken.Range;
- llvm::Optional<MatcherCtor> MappedMatcher =
+ std::optional<MatcherCtor> MappedMatcher =
S->lookupMatcherCtor(ArgValue.Text);
if (!MappedMatcher) {
@@ -628,7 +628,7 @@ bool Parser::parseMatcherBuilder(MatcherCtor Ctor, const TokenInfo &NameToken,
/// returns \c false.
bool Parser::parseMatcherExpressionImpl(const TokenInfo &NameToken,
const TokenInfo &OpenToken,
- llvm::Optional<MatcherCtor> Ctor,
+ std::optional<MatcherCtor> Ctor,
VariantValue *Value) {
if (!Ctor) {
Error->addError(NameToken.Range, Error->ET_RegistryMatcherNotFound)
@@ -828,7 +828,7 @@ Parser::Parser(CodeTokenizer *Tokenizer, Sema *S,
Parser::RegistrySema::~RegistrySema() = default;
-llvm::Optional<MatcherCtor>
+std::optional<MatcherCtor>
Parser::RegistrySema::lookupMatcherCtor(StringRef MatcherName) {
return Registry::lookupMatcherCtor(MatcherName);
}
@@ -904,19 +904,18 @@ Parser::completeExpression(StringRef &Code, unsigned CompletionOffset, Sema *S,
return P.Completions;
}
-llvm::Optional<DynTypedMatcher>
+std::optional<DynTypedMatcher>
Parser::parseMatcherExpression(StringRef &Code, Sema *S,
const NamedValueMap *NamedValues,
Diagnostics *Error) {
VariantValue Value;
if (!parseExpression(Code, S, NamedValues, &Value, Error))
- return llvm::Optional<DynTypedMatcher>();
+ return std::nullopt;
if (!Value.isMatcher()) {
Error->addError(SourceRange(), Error->ET_ParserNotAMatcher);
- return llvm::Optional<DynTypedMatcher>();
+ return std::nullopt;
}
- llvm::Optional<DynTypedMatcher> Result =
- Value.getMatcher().getSingleMatcher();
+ std::optional<DynTypedMatcher> Result = Value.getMatcher().getSingleMatcher();
if (!Result) {
Error->addError(SourceRange(), Error->ET_ParserOverloadedType)
<< Value.getTypeAsString();
diff --git a/clang/lib/ASTMatchers/Dynamic/Registry.cpp b/clang/lib/ASTMatchers/Dynamic/Registry.cpp
index 0a58652884ee..0d436fa29a79 100644
--- a/clang/lib/ASTMatchers/Dynamic/Registry.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/Registry.cpp
@@ -17,7 +17,6 @@
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/ASTMatchers/Dynamic/Diagnostics.h"
#include "clang/ASTMatchers/Dynamic/VariantValue.h"
-#include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
@@ -26,6 +25,7 @@
#include <cassert>
#include <iterator>
#include <memory>
+#include <optional>
#include <set>
#include <string>
#include <utility>
@@ -428,6 +428,7 @@ RegistryMaps::RegistryMaps() {
REGISTER_MATCHER(isPrivateKind);
REGISTER_MATCHER(isFirstPrivateKind);
REGISTER_MATCHER(isImplicit);
+ REGISTER_MATCHER(isInAnonymousNamespace);
REGISTER_MATCHER(isInStdNamespace);
REGISTER_MATCHER(isInTemplateInstantiation);
REGISTER_MATCHER(isInitCapture);
@@ -620,11 +621,10 @@ Registry::buildMatcherCtor(MatcherCtor Ctor, SourceRange NameRange,
}
// static
-llvm::Optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) {
+std::optional<MatcherCtor> Registry::lookupMatcherCtor(StringRef MatcherName) {
auto it = RegistryData->constructors().find(MatcherName);
- return it == RegistryData->constructors().end()
- ? llvm::Optional<MatcherCtor>()
- : it->second.get();
+ return it == RegistryData->constructors().end() ? std::optional<MatcherCtor>()
+ : it->second.get();
}
static llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
@@ -797,9 +797,9 @@ VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor,
VariantMatcher Out = constructMatcher(Ctor, NameRange, Args, Error);
if (Out.isNull()) return Out;
- llvm::Optional<DynTypedMatcher> Result = Out.getSingleMatcher();
+ std::optional<DynTypedMatcher> Result = Out.getSingleMatcher();
if (Result) {
- llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
+ std::optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
if (Bound) {
return VariantMatcher::SingleMatcher(*Bound);
}
diff --git a/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp b/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
index 813eb1597756..4f6b021b26f0 100644
--- a/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
@@ -14,6 +14,7 @@
#include "clang/ASTMatchers/Dynamic/VariantValue.h"
#include "clang/Basic/LLVM.h"
#include "llvm/ADT/STLExtras.h"
+#include <optional>
namespace clang {
namespace ast_matchers {
@@ -66,7 +67,7 @@ DynTypedMatcher VariantMatcher::MatcherOps::convertMatcher(
return Matcher.dynCastTo(NodeKind);
}
-llvm::Optional<DynTypedMatcher>
+std::optional<DynTypedMatcher>
VariantMatcher::MatcherOps::constructVariadicOperator(
DynTypedMatcher::VariadicOperator Op,
ArrayRef<VariantMatcher> InnerMatchers) const {
@@ -75,11 +76,11 @@ VariantMatcher::MatcherOps::constructVariadicOperator(
// Abort if any of the inner matchers can't be converted to
// Matcher<T>.
if (!InnerMatcher.Value)
- return llvm::None;
- llvm::Optional<DynTypedMatcher> Inner =
+ return std::nullopt;
+ std::optional<DynTypedMatcher> Inner =
InnerMatcher.Value->getTypedMatcher(*this);
if (!Inner)
- return llvm::None;
+ return std::nullopt;
DynMatchers.push_back(*Inner);
}
return DynTypedMatcher::constructVariadic(Op, NodeKind, DynMatchers);
@@ -91,7 +92,7 @@ class VariantMatcher::SinglePayload : public VariantMatcher::Payload {
public:
SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher) {}
- llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
+ std::optional<DynTypedMatcher> getSingleMatcher() const override {
return Matcher;
}
@@ -100,12 +101,12 @@ public:
.str();
}
- llvm::Optional<DynTypedMatcher>
+ std::optional<DynTypedMatcher>
getTypedMatcher(const MatcherOps &Ops) const override {
bool Ignore;
if (Ops.canConstructFrom(Matcher, Ignore))
return Matcher;
- return llvm::None;
+ return std::nullopt;
}
bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const override {
@@ -124,9 +125,9 @@ public:
~PolymorphicPayload() override {}
- llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
+ std::optional<DynTypedMatcher> getSingleMatcher() const override {
if (Matchers.size() != 1)
- return llvm::Optional<DynTypedMatcher>();
+ return std::nullopt;
return Matchers[0];
}
@@ -140,7 +141,7 @@ public:
return (Twine("Matcher<") + Inner + ">").str();
}
- llvm::Optional<DynTypedMatcher>
+ std::optional<DynTypedMatcher>
getTypedMatcher(const MatcherOps &Ops) const override {
bool FoundIsExact = false;
const DynTypedMatcher *Found = nullptr;
@@ -162,7 +163,7 @@ public:
// We only succeed if we found exactly one, or if we found an exact match.
if (Found && (FoundIsExact || NumFound == 1))
return *Found;
- return llvm::None;
+ return std::nullopt;
}
bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const override {
@@ -189,8 +190,8 @@ public:
std::vector<VariantMatcher> Args)
: Op(Op), Args(std::move(Args)) {}
- llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
- return llvm::Optional<DynTypedMatcher>();
+ std::optional<DynTypedMatcher> getSingleMatcher() const override {
+ return std::nullopt;
}
std::string getTypeAsString() const override {
@@ -203,7 +204,7 @@ public:
return Inner;
}
- llvm::Optional<DynTypedMatcher>
+ std::optional<DynTypedMatcher>
getTypedMatcher(const MatcherOps &Ops) const override {
return Ops.constructVariadicOperator(Op, Args);
}
@@ -240,8 +241,8 @@ VariantMatcher VariantMatcher::VariadicOperatorMatcher(
std::make_shared<VariadicOpPayload>(Op, std::move(Args)));
}
-llvm::Optional<DynTypedMatcher> VariantMatcher::getSingleMatcher() const {
- return Value ? Value->getSingleMatcher() : llvm::Optional<DynTypedMatcher>();
+std::optional<DynTypedMatcher> VariantMatcher::getSingleMatcher() const {
+ return Value ? Value->getSingleMatcher() : std::optional<DynTypedMatcher>();
}
void VariantMatcher::reset() { Value.reset(); }
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-01 03:34:51 +0000