static const QueryKind value = QK_SetOutputKind;
};
-template <> struct SetQueryKind<ast_type_traits::TraversalKind> {
+template <> struct SetQueryKind<TraversalKind> {
static const QueryKind value = QK_SetTraversalKind;
};
llvm_unreachable("Invalid output kind");
}
-QueryRef QueryParser::parseSetTraversalKind(
- ast_type_traits::TraversalKind QuerySession::*Var) {
+QueryRef QueryParser::parseSetTraversalKind(TraversalKind QuerySession::*Var) {
StringRef ValStr;
unsigned Value =
LexOrCompleteWord<unsigned>(this, ValStr)
- .Case("AsIs", ast_type_traits::TK_AsIs)
- .Case("IgnoreUnlessSpelledInSource",
- ast_type_traits::TK_IgnoreUnlessSpelledInSource)
+ .Case("AsIs", TK_AsIs)
+ .Case("IgnoreUnlessSpelledInSource", TK_IgnoreUnlessSpelledInSource)
.Default(~0u);
if (Value == ~0u) {
return new InvalidQuery("expected traversal kind, got '" + ValStr + "'");
}
- return new SetQuery<ast_type_traits::TraversalKind>(
- Var, static_cast<ast_type_traits::TraversalKind>(Value));
+ return new SetQuery<TraversalKind>(Var, static_cast<TraversalKind>(Value));
}
QueryRef QueryParser::endQuery(QueryRef Q) {
template <typename T> struct LexOrCompleteWord;
QueryRef parseSetBool(bool QuerySession::*Var);
- QueryRef
- parseSetTraversalKind(ast_type_traits::TraversalKind QuerySession::*Var);
+ QueryRef parseSetTraversalKind(TraversalKind QuerySession::*Var);
template <typename QueryType> QueryRef parseSetOutputKind();
QueryRef completeMatcherExpression();
QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs)
: ASTs(ASTs), PrintOutput(false), DiagOutput(true),
DetailedASTOutput(false), BindRoot(true), PrintMatcher(false),
- Terminate(false), TK(ast_type_traits::TK_AsIs) {}
+ Terminate(false), TK(TK_AsIs) {}
llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
bool PrintMatcher;
bool Terminate;
- ast_type_traits::TraversalKind TK;
+ TraversalKind TK;
llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues;
};
// Find uses of absl::StrSplit(..., "x") and absl::StrSplit(...,
// absl::ByAnyChar("x")) to transform them into absl::StrSplit(..., 'x').
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
callExpr(callee(functionDecl(hasName("::absl::StrSplit"))),
hasArgument(1, anyOf(ByAnyCharArg, SingleChar)),
unless(isInTemplateInstantiation()))
// absl::MaxSplits(absl::ByAnyChar("x"), N) to transform them into
// absl::MaxSplits('x', N).
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
callExpr(callee(functionDecl(hasName("::absl::MaxSplits"))),
hasArgument(0, anyOf(ByAnyCharArg,
ignoringParenCasts(SingleChar))),
has(callExpr(callee(functionDecl(*Strcat))).bind("StrCat")));
if (const auto *SubStrcatCall = selectFirst<const CallExpr>(
"StrCat",
- match(stmt(traverse(ast_type_traits::TK_AsIs,
+ match(stmt(traverse(TK_AsIs,
anyOf(cxxConstructExpr(IsAlphanum,
hasArgument(0, IsStrcat)),
IsStrcat))),
// StrCat on the RHS. The first argument of the StrCat call should be the same
// as the LHS. Ignore calls from template instantiations.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxOperatorCallExpr(
unless(isInTemplateInstantiation()),
hasOverloadedOperatorName("="),
// `absl::Hours(x)`
// where `x` is not of a built-in type.
Finder->addMatcher(
- traverse(
- ast_type_traits::TK_AsIs,
- implicitCastExpr(anyOf(hasCastKind(CK_UserDefinedConversion),
- has(implicitCastExpr(
- hasCastKind(CK_UserDefinedConversion)))),
- hasParent(callExpr(
- callee(functionDecl(
- DurationFactoryFunction(),
- unless(hasParent(functionTemplateDecl())))),
- hasArgument(0, expr().bind("arg")))))
- .bind("OuterExpr")),
+ traverse(TK_AsIs, implicitCastExpr(
+ anyOf(hasCastKind(CK_UserDefinedConversion),
+ has(implicitCastExpr(
+ hasCastKind(CK_UserDefinedConversion)))),
+ hasParent(callExpr(
+ callee(functionDecl(
+ DurationFactoryFunction(),
+ unless(hasParent(functionTemplateDecl())))),
+ hasArgument(0, expr().bind("arg")))))
+ .bind("OuterExpr")),
this);
}
"implicit conversion to 'int64_t' is deprecated in this context; use an "
"explicit cast instead";
- TraversalKindScope RAII(*Result.Context, ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(*Result.Context, TK_AsIs);
const auto *ArgExpr = Result.Nodes.getNodeAs<Expr>("arg");
SourceLocation Loc = ArgExpr->getBeginLoc();
void AssertSideEffectCheck::registerMatchers(MatchFinder *Finder) {
auto DescendantWithSideEffect =
- traverse(ast_type_traits::TK_AsIs,
- hasDescendant(expr(hasSideEffect(CheckFunctionCalls))));
+ traverse(TK_AsIs, hasDescendant(expr(hasSideEffect(CheckFunctionCalls))));
auto ConditionWithSideEffect = hasCondition(DescendantWithSideEffect);
Finder->addMatcher(
stmt(
// condition. Filter negations.
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
ifStmt(
hasCondition(findAll(implicitCastExpr(
unless(hasParent(unaryOperator(hasOperatorName("!")))),
// Find 'Handle foo = ReturnsAValue();'
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
varDecl(hasType(hasUnqualifiedDesugaredType(recordType(
hasDeclaration(cxxRecordDecl(IsAHandle))))),
unless(parmVarDecl()),
this);
// Find 'foo = ReturnsAValue(); // foo is Handle'
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxOperatorCallExpr(callee(cxxMethodDecl(ofClass(IsAHandle))),
hasOverloadedOperatorName("="),
hasArgument(1, ConvertedHandle))
this);
// Container insertions that will dangle.
- Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
- makeContainerMatcher(IsAHandle).bind("bad_stmt")),
- this);
+ Finder->addMatcher(
+ traverse(TK_AsIs, makeContainerMatcher(IsAHandle).bind("bad_stmt")),
+ this);
}
void DanglingHandleCheck::registerMatchersForReturn(MatchFinder *Finder) {
// Return a local.
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
returnStmt(
// The AST contains two constructor calls:
// 1. Value to Handle conversion.
// Return a temporary.
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
returnStmt(has(exprWithCleanups(has(ignoringParenImpCasts(handleFrom(
IsAHandle, handleFromTemporaryValue(IsAHandle)))))))
.bind("bad_stmt")),
tagType(hasDeclaration(decl(isInStdNamespace())))));
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxMemberCallExpr(
on(anyOf(hasType(DeclInStd), hasType(pointsTo(DeclInStd)))),
callee(cxxMethodDecl(hasName("erase"))), argumentCountIs(1),
// Find expressions of cast to int of the sum of a floating point expression
// and 0.5.
MatchFinder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
implicitCastExpr(hasImplicitDestinationType(isInteger()),
ignoringParenCasts(binaryOperator(
hasOperatorName("+"), OneSideHalf)))
callExpr(IntType), explicitCastExpr(IntType), UnaryOperators);
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
binaryOperator(
hasOperatorName("/"), hasLHS(expr(IntType)),
hasRHS(expr(IntType)),
declRefExpr(hasDeclaration(Alloc1Func)))));
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
- callExpr(callee(decl(anyOf(Alloc0Func, Alloc0FuncPtr))),
- hasArgument(0, BadArg))
- .bind("Alloc")),
+ traverse(TK_AsIs, callExpr(callee(decl(anyOf(Alloc0Func, Alloc0FuncPtr))),
+ hasArgument(0, BadArg))
+ .bind("Alloc")),
this);
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
- callExpr(callee(decl(anyOf(Alloc1Func, Alloc1FuncPtr))),
- hasArgument(1, BadArg))
- .bind("Alloc")),
+ traverse(TK_AsIs, callExpr(callee(decl(anyOf(Alloc1Func, Alloc1FuncPtr))),
+ hasArgument(1, BadArg))
+ .bind("Alloc")),
this);
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxNewExpr(isArray(), hasArraySize(BadArg)).bind("Alloc")),
this);
}
implicitCastExpr(hasImplicitDestinationType(isInteger()),
has(ignoringParenImpCasts(Calc)));
const auto Cast =
- traverse(ast_type_traits::TK_AsIs,
- expr(anyOf(ExplicitCast, ImplicitCast)).bind("Cast"));
+ traverse(TK_AsIs, expr(anyOf(ExplicitCast, ImplicitCast)).bind("Cast"));
Finder->addMatcher(varDecl(hasInitializer(Cast)), this);
Finder->addMatcher(returnStmt(hasReturnValue(Cast)), this);
void ParentVirtualCallCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxMemberCallExpr(
callee(memberExpr(hasDescendant(implicitCastExpr(
hasImplicitDestinationType(pointsTo(
// We catch any type of casts to an integer. We need to have these cast
// expressions explicitly to catch only those casts which are direct children
// of the checked expressions. (e.g. assignment, declaration).
- return traverse(ast_type_traits::TK_AsIs,
- expr(anyOf(ImplicitCastExpr, CStyleCastExpr, StaticCastExpr,
- FunctionalCastExpr)));
+ return traverse(TK_AsIs, expr(anyOf(ImplicitCastExpr, CStyleCastExpr,
+ StaticCastExpr, FunctionalCastExpr)));
}
void SignedCharMisuseCheck::registerMatchers(MatchFinder *Finder) {
// String literals surrounded by parentheses are assumed to be on purpose.
// i.e.: const char* Array[] = { ("a" "b" "c"), "d", [...] };
- TraversalKindScope RAII(*Ctx, ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(*Ctx, TK_AsIs);
auto Parents = Ctx->getParents(*Lit);
if (Parents.size() == 1 && Parents[0].get<ParenExpr>() != nullptr)
return true;
// Detect suspicious cast to an inconsistant type (i.e. not integer type).
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
implicitCastExpr(unless(hasType(isInteger())),
hasSourceExpression(StringCompareCallExpr))
.bind("invalid-conversion")),
.bind(LoopVarName);
// We need to catch only those comparisons which contain any integer cast.
- StatementMatcher LoopVarConversionMatcher =
- traverse(ast_type_traits::TK_AsIs,
- implicitCastExpr(hasImplicitDestinationType(isInteger()),
+ StatementMatcher LoopVarConversionMatcher = traverse(
+ TK_AsIs, implicitCastExpr(hasImplicitDestinationType(isInteger()),
has(ignoringParenImpCasts(LoopVarMatcher)))
.bind(LoopVarCastName));
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
compoundStmt(hasParent(cxxConstructorDecl(
ofClass(cxxRecordDecl().bind("parent")))),
forEach(ignoringTemporaryExpr(
// In the non-template case, we can search for the copy constructor call.
const auto HasNonTemplateSelfCopy = cxxMethodDecl(
ofClass(cxxRecordDecl(unless(hasAncestor(classTemplateDecl())))),
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
hasDescendant(cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
isCopyConstructor(), ofClass(equalsBoundNode("class"))))))));
unless(has(ignoringParenImpCasts(objcMessageExpr()))))
.bind("temp");
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
exprWithCleanups(
unless(isInTemplateInstantiation()),
hasParent(compoundStmt().bind("compound")),
unless(inDecltypeOrTemplateArg()))
.bind("declref");
- addDeclRefs(
- match(traverse(ast_type_traits::TK_AsIs, findAll(DeclRefMatcher)),
- *S->getStmt(), *Context));
+ addDeclRefs(match(traverse(TK_AsIs, findAll(DeclRefMatcher)), *S->getStmt(),
+ *Context));
addDeclRefs(match(findAll(cxxOperatorCallExpr(
hasAnyOverloadedOperatorName("*", "->", "[]"),
hasArgument(0, DeclRefMatcher))
// Passing variable to a function as a non-const lvalue reference
// (unless that function is std::move()).
callExpr(forEachArgumentWithParam(
- traverse(ast_type_traits::TK_AsIs, DeclRefMatcher),
+ traverse(TK_AsIs, DeclRefMatcher),
unless(parmVarDecl(hasType(
references(qualType(isConstQualified())))))),
unless(callee(functionDecl(hasName("::std::move")))))))
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
// To find the Stmt that we assume performs the actual move, we look
// for the direct ancestor of the std::move() that isn't one of the
// node types ignored by ignoringParenImpCasts().
MemberExprOrSourceObject);
const auto IsSourceMutatingAssignment = traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
expr(anyOf(binaryOperator(isAssignmentOperator(), hasLHS(IsPartOfSource))
.bind(MutatingOperatorName),
cxxOperatorCallExpr(isAssignmentOperator(),
// std::mt19937 engine(x);
// ^
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxConstructExpr(RandomGeneratorEngineTypeMatcher).bind("ctor")),
this);
// initializer that can throw.
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
varDecl(
anyOf(hasThreadStorageDuration(), hasStaticStorageDuration()),
unless(anyOf(isConstexpr(), hasType(cxxRecordDecl(isLambda())),
void ThrownExceptionTypeCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxThrowExpr(has(ignoringParenImpCasts(
cxxConstructExpr(hasDeclaration(cxxConstructorDecl(
isCopyConstructor(), unless(isNoThrow()))))
const auto ReferencesUndefinedGlobalVar = declRefExpr(hasDeclaration(
varDecl(GlobalVarDecl, unless(isDefinition())).bind("referencee")));
- Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
- varDecl(GlobalVarDecl, isDefinition(),
- hasInitializer(expr(hasDescendant(
- ReferencesUndefinedGlobalVar))))
- .bind("var")),
- this);
+ Finder->addMatcher(
+ traverse(TK_AsIs, varDecl(GlobalVarDecl, isDefinition(),
+ hasInitializer(expr(hasDescendant(
+ ReferencesUndefinedGlobalVar))))
+ .bind("var")),
+ this);
}
void InterfacesGlobalInitCheck::check(const MatchFinder::MatchResult &Result) {
// i = 0.5;
// void f(int); f(0.5);
Finder->addMatcher(
- traverse(
- ast_type_traits::TK_AsIs,
- implicitCastExpr(hasImplicitDestinationType(
- hasUnqualifiedDesugaredType(builtinType())),
- hasSourceExpression(hasType(
- hasUnqualifiedDesugaredType(builtinType()))),
- unless(hasSourceExpression(IsCeilFloorCallExpr)),
- unless(hasParent(castExpr())),
- unless(isInTemplateInstantiation()))
- .bind("cast")),
+ traverse(TK_AsIs, implicitCastExpr(
+ hasImplicitDestinationType(
+ hasUnqualifiedDesugaredType(builtinType())),
+ hasSourceExpression(hasType(
+ hasUnqualifiedDesugaredType(builtinType()))),
+ unless(hasSourceExpression(IsCeilFloorCallExpr)),
+ unless(hasParent(castExpr())),
+ unless(isInTemplateInstantiation()))
+ .bind("cast")),
this);
// Binary operators:
// Find delete expressions that delete non-owners.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxDeleteExpr(hasDescendant(declRefExpr(unless(ConsideredOwner))
.bind("deleted_variable")))
.bind("delete_expr")),
// resources. This check assumes that all pointer arguments of a legacy
// functions shall be 'gsl::owner<>'.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
- callExpr(callee(LegacyOwnerConsumers),
- hasAnyArgument(
- expr(unless(ignoringImpCasts(ConsideredOwner)),
- hasType(pointerType()))))
- .bind("legacy_consumer")),
+ traverse(TK_AsIs, callExpr(callee(LegacyOwnerConsumers),
+ hasAnyArgument(expr(
+ unless(ignoringImpCasts(ConsideredOwner)),
+ hasType(pointerType()))))
+ .bind("legacy_consumer")),
this);
// Matching assignment to owners, with the rhs not being an owner nor creating
// one.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
binaryOperator(isAssignmentOperator(), hasLHS(IsOwnerType),
hasRHS(unless(ConsideredOwner)))
.bind("owner_assignment")),
// Matching initialization of owners with non-owners, nor creating owners.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
namedDecl(
varDecl(hasInitializer(unless(ConsideredOwner)), IsOwnerType)
.bind("owner_initialization"))),
// Match class member initialization that expects owners, but does not get
// them.
- Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
- cxxRecordDecl(HasConstructorInitializerForOwner)),
- this);
+ Finder->addMatcher(
+ traverse(TK_AsIs, cxxRecordDecl(HasConstructorInitializerForOwner)),
+ this);
// Matching on assignment operations where the RHS is a newly created owner,
// but the LHS is not an owner.
// created owner, but the LHS is not an owner.
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
namedDecl(
varDecl(eachOf(allOf(hasInitializer(CreatesOwner),
unless(IsOwnerType)),
// 2) inside a range-for over an array
// 3) if it converts a string literal to a pointer
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
implicitCastExpr(
unless(hasParent(arraySubscriptExpr())),
unless(hasParentIgnoringImpCasts(explicitCastExpr())),
// constructor in DerivedDecl's constructors.
unless(IsWithinDerivedCtor));
- Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
- expr(anyOf(SlicesObjectInAssignment, SlicesObjectInCtor))
- .bind("Call")),
- this);
+ Finder->addMatcher(traverse(TK_AsIs, expr(anyOf(SlicesObjectInAssignment,
+ SlicesObjectInCtor))
+ .bind("Call")),
+ this);
}
/// Warns on methods overridden in DerivedDecl with respect to BaseDecl.
void StaticallyConstructedObjectsCheck::registerMatchers(MatchFinder *Finder) {
// Constructing global, non-trivial objects with static storage is
- // disallowed, unless the object is statically initialized with a constexpr
+ // disallowed, unless the object is statically initialized with a constexpr
// constructor or has no explicit constructor.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
varDecl(
// Match global, statically stored objects...
isGlobalStatic(),
.bind("rhs");
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
stmt(anyOf(
ifStmt(Any), whileStmt(Any), doStmt(Condition),
binaryOperator(
cxxRecordDecl(hasName("::llvm::Register")).bind("registerClassDecl"));
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
valueDecl(allOf(
hasType(qualType(isUnsignedInteger()).bind("varType")),
varDecl(hasInitializer(exprWithCleanups(
ASTContext &Context) {
// IgnoreParenImpCasts logic in reverse: skip surrounding uninteresting nodes
const DynTypedNodeList Parents = Context.getParents(*TheExpr);
- for (ast_type_traits::DynTypedNode DynParent : Parents) {
+ for (DynTypedNode DynParent : Parents) {
if (const auto *Parent = DynParent.get<Expr>()) {
bool Skip = isa<ParenExpr>(Parent) || isa<ImplicitCastExpr>(Parent) ||
isa<FullExpr>(Parent) ||
if (areEquivalentExpr(AllOperands[I], AllOperands[J])) {
FoundDuplicates = true;
Duplicates.set(J);
- Builder->setBinding(
- SmallString<11>(llvm::formatv("duplicate{0}", J)),
- ast_type_traits::DynTypedNode::create(*AllOperands[J]));
+ Builder->setBinding(SmallString<11>(llvm::formatv("duplicate{0}", J)),
+ DynTypedNode::create(*AllOperands[J]));
}
}
if (FoundDuplicates)
- Builder->setBinding(
- SmallString<11>(llvm::formatv("duplicate{0}", I)),
- ast_type_traits::DynTypedNode::create(*AllOperands[I]));
+ Builder->setBinding(SmallString<11>(llvm::formatv("duplicate{0}", I)),
+ DynTypedNode::create(*AllOperands[I]));
}
return Duplicates.any();
// Binary with equivalent operands, like (X != 2 && X != 2).
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
binaryOperator(
anyOf(isComparisonOperator(),
hasAnyOperatorName("-", "/", "%", "|", "&", "^", "&&",
// Conditional (trenary) operator with equivalent operands, like (Y ? X : X).
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
conditionalOperator(expressionsAreEquivalent(),
// Filter noisy false positives.
unless(conditionalOperatorIsInMacro()),
// Overloaded operators with equivalent operands.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxOperatorCallExpr(
hasAnyOverloadedOperatorName("-", "/", "%", "|", "&", "^",
"==", "!=", "<", "<=", ">",
// Match expressions like: !(1 | 2 | 3)
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
implicitCastExpr(
hasImplicitDestinationType(isInteger()),
has(unaryOperator(
.bind("logical-bitwise-confusion")))),
this);
- // Match expressions like: (X << 8) & 0xFF
- Finder->addMatcher(
- traverse(
- ast_type_traits::TK_AsIs,
- binaryOperator(
- hasOperatorName("&"),
- hasOperands(
- ignoringParenImpCasts(
- binaryOperator(hasOperatorName("<<"),
- hasRHS(ignoringParenImpCasts(
- integerLiteral().bind("shift-const"))))),
- ignoringParenImpCasts(integerLiteral().bind("and-const"))))
- .bind("left-right-shift-confusion")),
- this);
+ // Match expressions like: (X << 8) & 0xFF
+ Finder->addMatcher(
+ traverse(TK_AsIs,
+ binaryOperator(
+ hasOperatorName("&"),
+ hasOperands(ignoringParenImpCasts(binaryOperator(
+ hasOperatorName("<<"),
+ hasRHS(ignoringParenImpCasts(
+ integerLiteral().bind("shift-const"))))),
+ ignoringParenImpCasts(
+ integerLiteral().bind("and-const"))))
+ .bind("left-right-shift-confusion")),
+ this);
// Match common expressions and apply more checks to find redundant
// sub-expressions.
const auto SymRight = matchSymbolicExpr("rhs");
// Match expressions like: x <op> 0xFF == 0xF00.
- Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
- binaryOperator(isComparisonOperator(),
- hasOperands(BinOpCstLeft,
- CstRight))
- .bind("binop-const-compare-to-const")),
- this);
+ Finder->addMatcher(
+ traverse(TK_AsIs, binaryOperator(isComparisonOperator(),
+ hasOperands(BinOpCstLeft, CstRight))
+ .bind("binop-const-compare-to-const")),
+ this);
// Match expressions like: x <op> 0xFF == x.
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
binaryOperator(isComparisonOperator(),
anyOf(allOf(hasLHS(BinOpCstLeft), hasRHS(SymRight)),
allOf(hasLHS(SymRight), hasRHS(BinOpCstLeft))))
// Match expressions like: x <op> 10 == x <op> 12.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
binaryOperator(isComparisonOperator(), hasLHS(BinOpCstLeft),
hasRHS(BinOpCstRight),
// Already reported as redundant.
const auto ComparisonLeft = matchRelationalIntegerConstantExpr("lhs");
const auto ComparisonRight = matchRelationalIntegerConstantExpr("rhs");
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
binaryOperator(hasAnyOperatorName("||", "&&"),
hasLHS(ComparisonLeft), hasRHS(ComparisonRight),
// Already reported as redundant.
}
void LoopConvertCheck::registerMatchers(MatchFinder *Finder) {
- Finder->addMatcher(traverse(ast_type_traits::TK_AsIs, makeArrayLoopMatcher()),
- this);
- Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs, makeIteratorLoopMatcher(false)), this);
- Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs, makePseudoArrayLoopMatcher()), this);
+ Finder->addMatcher(traverse(TK_AsIs, makeArrayLoopMatcher()), this);
+ Finder->addMatcher(traverse(TK_AsIs, makeIteratorLoopMatcher(false)), this);
+ Finder->addMatcher(traverse(TK_AsIs, makePseudoArrayLoopMatcher()), this);
if (UseReverseRanges)
- Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs, makeIteratorLoopMatcher(true)),
- this);
+ Finder->addMatcher(traverse(TK_AsIs, makeIteratorLoopMatcher(true)), this);
}
/// Given the range of a single declaration, such as:
}
// Find out which qualifiers we have to use in the loop range.
- TraversalKindScope RAII(*Context, ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(*Context, TK_AsIs);
const UsageResult &Usages = Finder.getUsages();
determineRangeDescriptor(Context, Nodes, Loop, FixerKind, ContainerExpr,
Usages, Descriptor);
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxBindTemporaryExpr(has(ignoringParenImpCasts(
cxxConstructExpr(
hasType(getSmartPointerTypeMatcher()), argumentCountIs(1),
this);
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxMemberCallExpr(
thisPointerType(getSmartPointerTypeMatcher()),
callee(cxxMethodDecl(hasName("reset"))),
const CXXNewExpr *New, SourceManager &SM,
ASTContext *Ctx) {
auto SkipParensParents = [&](const Expr *E) {
- TraversalKindScope RAII(*Ctx, ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(*Ctx, TK_AsIs);
for (const Expr *OldE = nullptr; E != OldE;) {
OldE = E;
void PassByValueCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxConstructorDecl(
forEachConstructorInitializer(
cxxCtorInitializer(
hasArgument(1, MovableArgumentMatcher)),
this);
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxConstructExpr(hasType(AutoPtrType), argumentCountIs(1),
hasArgument(0, MovableArgumentMatcher))),
this);
const auto RandomFunc = hasArgument(2, expr().bind("randomFunc"));
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
callExpr(
anyOf(allOf(Begin, End, argumentCountIs(2)),
allOf(Begin, End, RandomFunc, argumentCountIs(3))),
has(ConstructExpr), has(cxxFunctionalCastExpr(has(ConstructExpr)))));
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
functionDecl(
isDefinition(), // Declarations don't have return statements.
returns(unless(anyOf(builtinType(), autoType()))),
on(hasType(hasCanonicalType(hasDeclaration(namedDecl(
hasAnyName("std::basic_string", "std::deque", "std::vector")))))),
callee(cxxMethodDecl(hasName("swap"))),
- has(ignoringParenImpCasts(memberExpr(traverse(
- ast_type_traits::TK_AsIs, hasDescendant(CopyCtorCall))))),
+ has(ignoringParenImpCasts(
+ memberExpr(traverse(TK_AsIs, hasDescendant(CopyCtorCall))))),
hasArgument(0, SwapParam.bind("ContainerToShrink")),
unless(isInTemplateInstantiation()))
.bind("CopyAndSwapTrick"),
}
void UseAutoCheck::registerMatchers(MatchFinder *Finder) {
- Finder->addMatcher(traverse(ast_type_traits::TK_AsIs, makeCombinedMatcher()),
- this);
+ Finder->addMatcher(traverse(TK_AsIs, makeCombinedMatcher()), this);
}
void UseAutoCheck::replaceIterators(const DeclStmt *D, ASTContext *Context) {
void UseBoolLiteralsCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
implicitCastExpr(
has(ignoringParenImpCasts(integerLiteral().bind("literal"))),
hasImplicitDestinationType(qualType(booleanType())),
this);
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
conditionalOperator(
hasParent(implicitCastExpr(
hasImplicitDestinationType(qualType(booleanType())),
HasConstructExpr, has(cxxFunctionalCastExpr(HasConstructExpr))));
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
- cxxMemberCallExpr(CallPushBack, has(SoughtParam),
- unless(isInTemplateInstantiation()))
- .bind("call")),
+ traverse(TK_AsIs, cxxMemberCallExpr(CallPushBack, has(SoughtParam),
+ unless(isInTemplateInstantiation()))
+ .bind("call")),
this);
}
// The initialization of a base class should be a call to a copy
// constructor of the base.
if (match(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxConstructorDecl(
forEachConstructorInitializer(cxxCtorInitializer(
isBaseInitializer(),
auto AccessToFieldInParam = accessToFieldInVar(Field, Param);
// The initialization is a CXXConstructExpr for class types.
if (match(traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxConstructorDecl(
forEachConstructorInitializer(cxxCtorInitializer(
isMemberInitializer(), forField(equalsNode(Field)),
// return *this;
if (Compound->body_empty() ||
match(traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
returnStmt(has(ignoringParenImpCasts(unaryOperator(
hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())))))),
*Compound->body_back(), *Context)
// ((Base*)this)->operator=((Base)Other);
//
// So we are looking for a member call that fulfills:
- if (match(traverse(ast_type_traits::TK_AsIs,
+ if (match(traverse(TK_AsIs,
compoundStmt(has(ignoringParenImpCasts(cxxMemberCallExpr(
// - The object is an implicit cast of 'this' to a
// pointer to
member(fieldDecl(equalsNode(Field))));
auto RHS = accessToFieldInVar(Field, Param);
if (match(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
compoundStmt(has(ignoringParenImpCasts(stmt(anyOf(
binaryOperator(hasOperatorName("="), hasLHS(LHS),
hasRHS(RHS)),
unless(hasSourceExpression(hasType(sugaredNullptrType()))));
return traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
castExpr(anyOf(ImplicitCastToNull,
explicitCastExpr(hasDescendant(ImplicitCastToNull))),
unless(hasAncestor(explicitCastExpr())))
return false;
// Step 2: Find the first ancestor that doesn't expand from this macro.
- ast_type_traits::DynTypedNode ContainingAncestor;
- if (!findContainingAncestor(
- ast_type_traits::DynTypedNode::create<Stmt>(*CE), MacroLoc,
- ContainingAncestor))
+ DynTypedNode ContainingAncestor;
+ if (!findContainingAncestor(DynTypedNode::create<Stmt>(*CE), MacroLoc,
+ ContainingAncestor))
return false;
// Step 3:
///
/// \pre MacroLoc.isFileID()
/// \returns true if such an ancestor was found, false otherwise.
- bool findContainingAncestor(ast_type_traits::DynTypedNode Start,
- SourceLocation MacroLoc,
- ast_type_traits::DynTypedNode &Result) {
+ bool findContainingAncestor(DynTypedNode Start, SourceLocation MacroLoc,
+ DynTypedNode &Result) {
// Below we're only following the first parent back up the AST. This should
// be fine since for the statements we care about there should only be one
// parent, except for the case specified below.
}
}
- const ast_type_traits::DynTypedNode &Parent = Parents[0];
+ const DynTypedNode &Parent = Parents[0];
SourceLocation Loc;
if (const auto *D = Parent.get<Decl>())
void NSInvocationArgumentLifetimeCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
objcMessageExpr(
hasReceiverType(asString("NSInvocation *")),
anyOf(hasSelector("getArgument:atIndex:"),
unless(hasInitializer(expr(hasDescendant(expr(anyOf(
materializeTemporaryExpr(), IteratorReturnsValueType)))))));
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxForRangeStmt(hasLoopVariable(LoopVar.bind("loopVar")))
.bind("forRange")),
this);
// cxxOperatorCallExpr() matcher.
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxForRangeStmt(hasLoopVariable(
varDecl(
hasType(qualType(references(qualType(isConstQualified())))),
"::std::unordered_multiset", "::std::unordered_multimap"));
const auto Matcher = traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
callExpr(
callee(functionDecl(Algorithms)),
hasArgument(
Finder->addMatcher(callExpr(ConstParamMatcher).bind("receiving-expr"), this);
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxConstructExpr(ConstParamMatcher).bind("receiving-expr")),
this);
}
void MoveConstructorInitCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxConstructorDecl(
unless(isImplicit()), isMoveConstructor(),
hasAnyConstructorInitializer(
pointee(type(equalsBoundNode("SrcT")))))))))));
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
returnStmt(hasReturnValue(
ignoringElidableConstructorCall(ignoringParenImpCasts(
cxxConstructExpr(
AllowedTypes)))))),
unless(isImplicit()),
hasInitializer(traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxConstructExpr(
hasDeclaration(cxxConstructorDecl(
isCopyConstructor())),
const auto *BlockStmt = Result.Nodes.getNodeAs<Stmt>("blockStmt");
const auto *CtorCall = Result.Nodes.getNodeAs<CXXConstructExpr>("ctorCall");
- TraversalKindScope RAII(*Result.Context, ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(*Result.Context, TK_AsIs);
// Do not propose fixes if the DeclStmt has multiple VarDecls or in macros
// since we cannot place them correctly.
bool hasLoopStmtAncestor(const DeclRefExpr &DeclRef, const Decl &Decl,
ASTContext &Context) {
auto Matches = match(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
decl(forEachDescendant(declRefExpr(
equalsNode(&DeclRef),
unless(hasAncestor(stmt(anyOf(forStmt(), cxxForRangeStmt(),
decl().bind("param"));
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
functionDecl(hasBody(stmt()), isDefinition(), unless(isImplicit()),
unless(cxxMethodDecl(anyOf(isOverride(), isFinal()))),
has(typeLoc(forEach(ExpensiveValueParamDecl))),
const auto *Param = Result.Nodes.getNodeAs<ParmVarDecl>("param");
const auto *Function = Result.Nodes.getNodeAs<FunctionDecl>("functionDecl");
- TraversalKindScope RAII(*Result.Context, ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(*Result.Context, TK_AsIs);
FunctionParmMutationAnalyzer &Analyzer =
MutationAnalyzers.try_emplace(Function, *Function, *Result.Context)
.bind("container")))))));
const auto WrongUse = traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
anyOf(
hasParent(binaryOperator(isComparisonOperator(),
hasEitherOperand(ignoringImpCasts(
hasOperands(castExpr(hasCastKind(CK_NullToPointer)), PointerExpr));
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
ifStmt(hasCondition(
anyOf(PointerCondition, BinaryPointerCheckCondition)),
hasThen(anyOf(DeleteExpr, DeleteMemberExpr,
std::queue<const Stmt *> Q;
Q.push(Cast);
- TraversalKindScope RAII(Context, ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(Context, TK_AsIs);
while (!Q.empty()) {
for (const auto &N : Context.getParents(*Q.front())) {
binaryOperator(hasOperatorName("^"), hasLHS(implicitCastFromBool),
hasRHS(implicitCastFromBool));
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
implicitCastExpr(
anyOf(hasCastKind(CK_IntegralToBoolean),
hasCastKind(CK_FloatingToBoolean),
forField(hasBitWidth(1)))));
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
implicitCastExpr(
implicitCastFromBool,
// Exclude comparisons of bools, as they are always cast to
void MagicNumbersCheck::check(const MatchFinder::MatchResult &Result) {
- TraversalKindScope RAII(*Result.Context, ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(*Result.Context, TK_AsIs);
checkBoundMatch<IntegerLiteral>(Result, "integer");
checkBoundMatch<FloatingLiteral>(Result, "float");
void MakeMemberFunctionConstCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxMethodDecl(
isDefinition(), isUserProvided(),
unless(anyOf(
void MisplacedArrayIndexCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
- arraySubscriptExpr(hasLHS(hasType(isInteger())),
- hasRHS(hasType(isAnyPointer())))
- .bind("expr")),
+ traverse(TK_AsIs, arraySubscriptExpr(hasLHS(hasType(isInteger())),
+ hasRHS(hasType(isAnyPointer())))
+ .bind("expr")),
this);
}
// Analyse parameter usage in function.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
stmt(anyOf(unaryOperator(hasAnyOperatorName("++", "--")),
binaryOperator(), callExpr(), returnStmt(),
cxxConstructExpr()))
namespace readability {
void RedundantFunctionPtrDereferenceCheck::registerMatchers(MatchFinder *Finder) {
- Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
- unaryOperator(hasOperatorName("*"),
- has(implicitCastExpr(hasCastKind(
- CK_FunctionToPointerDecay))))
- .bind("op")),
- this);
+ Finder->addMatcher(
+ traverse(TK_AsIs, unaryOperator(hasOperatorName("*"),
+ has(implicitCastExpr(hasCastKind(
+ CK_FunctionToPointerDecay))))
+ .bind("op")),
+ this);
}
void RedundantFunctionPtrDereferenceCheck::check(const MatchFinder::MatchResult &Result) {
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxConstructorDecl(
unless(isDelegatingConstructor()),
ofClass(unless(
// check that matched ParamDecl of the ancestor CallExpr is not rvalue.
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxConstructExpr(
StringConstructorExpr, hasArgument(0, StringCStrCallExpr),
unless(anyOf(HasRValueTempParent, hasParent(cxxBindTemporaryExpr(
// Detect redundant 'c_str()' calls through a StringRef constructor.
Finder->addMatcher(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxConstructExpr(
// Implicit constructors of these classes are overloaded
// wrt. string types and they internally make a StringRef
const auto StringType = hasType(hasUnqualifiedDesugaredType(
recordType(hasDeclaration(cxxRecordDecl(hasStringTypeName)))));
- const auto EmptyStringInit =
- traverse(ast_type_traits::TK_AsIs, expr(ignoringImplicit(
- anyOf(EmptyStringCtorExpr, EmptyStringCtorExprWithTemporaries))));
+ const auto EmptyStringInit = traverse(
+ TK_AsIs, expr(ignoringImplicit(anyOf(
+ EmptyStringCtorExpr, EmptyStringCtorExprWithTemporaries))));
// Match a variable declaration with an empty string literal as initializer.
// Examples:
// string foo = "";
// string bar("");
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
namedDecl(varDecl(StringType, hasInitializer(EmptyStringInit))
.bind("vardecl"),
unless(parmVarDecl()))),
// First and second case: cast str.compare(str) to boolean.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
implicitCastExpr(hasImplicitDestinationType(booleanType()),
has(StrCompare))
.bind("match1")),
ASTContext *Context) {
SmallVector<const Stmt *, 1> Result;
- TraversalKindScope RAII(*Context, ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(*Context, TK_AsIs);
DynTypedNodeList Parents = Context->getParents(*S);
- SmallVector<ast_type_traits::DynTypedNode, 1> NodesToProcess(Parents.begin(),
- Parents.end());
+ SmallVector<DynTypedNode, 1> NodesToProcess(Parents.begin(), Parents.end());
while (!NodesToProcess.empty()) {
- ast_type_traits::DynTypedNode Node = NodesToProcess.back();
+ DynTypedNode Node = NodesToProcess.back();
NodesToProcess.pop_back();
if (const auto *S = Node.get<Stmt>()) {
// Matcher for user-defined constructors.
Finder->addMatcher(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
cxxConstructExpr(hasParent(cxxFunctionalCastExpr()),
hasDeclaration(cxxConstructorDecl(hasParent(
cxxRecordDecl(matchesAnyName(Names))))))
std::string printType(const QualType QT, const DeclContext &CurContext) {
std::string Result;
llvm::raw_string_ostream OS(Result);
- auto Decls = explicitReferenceTargets(
- ast_type_traits::DynTypedNode::create(QT), DeclRelation::Alias);
+ auto Decls =
+ explicitReferenceTargets(DynTypedNode::create(QT), DeclRelation::Alias);
if (!Decls.empty())
OS << getQualification(CurContext.getParentASTContext(), &CurContext,
Decls.front(),
namespace clang {
namespace clangd {
namespace {
-using ast_type_traits::DynTypedNode;
-LLVM_ATTRIBUTE_UNUSED std::string
-nodeToString(const ast_type_traits::DynTypedNode &N) {
+LLVM_ATTRIBUTE_UNUSED std::string nodeToString(const DynTypedNode &N) {
std::string S = std::string(N.getNodeKind().asStringRef());
{
llvm::raw_string_ostream OS(S);
RelSet Flags;
template <typename T> void debug(T &Node, RelSet Flags) {
- dlog("visit [{0}] {1}", Flags,
- nodeToString(ast_type_traits::DynTypedNode::create(Node)));
+ dlog("visit [{0}] {1}", Flags, nodeToString(DynTypedNode::create(Node)));
}
void report(const NamedDecl *D, RelSet Flags) {
- dlog("--> [{0}] {1}", Flags,
- nodeToString(ast_type_traits::DynTypedNode::create(*D)));
+ dlog("--> [{0}] {1}", Flags, nodeToString(DynTypedNode::create(*D)));
auto It = Decls.try_emplace(D, std::make_pair(Flags, Decls.size()));
// If already exists, update the flags.
if (!It.second)
} // namespace
llvm::SmallVector<std::pair<const NamedDecl *, DeclRelationSet>, 1>
-allTargetDecls(const ast_type_traits::DynTypedNode &N) {
+allTargetDecls(const DynTypedNode &N) {
dlog("allTargetDecls({0})", nodeToString(N));
TargetFinder Finder;
DeclRelationSet Flags;
return Finder.takeDecls();
}
-llvm::SmallVector<const NamedDecl *, 1>
-targetDecl(const ast_type_traits::DynTypedNode &N, DeclRelationSet Mask) {
+llvm::SmallVector<const NamedDecl *, 1> targetDecl(const DynTypedNode &N,
+ DeclRelationSet Mask) {
llvm::SmallVector<const NamedDecl *, 1> Result;
for (const auto &Entry : allTargetDecls(N)) {
if (!(Entry.second & ~Mask))
/// If callers want to support such decls, they should cast the node directly.
///
/// FIXME: some AST nodes cannot be DynTypedNodes, these cannot be specified.
-llvm::SmallVector<const NamedDecl *, 1>
-targetDecl(const ast_type_traits::DynTypedNode &, DeclRelationSet Mask);
+llvm::SmallVector<const NamedDecl *, 1> targetDecl(const DynTypedNode &,
+ DeclRelationSet Mask);
/// Similar to targetDecl(), however instead of applying a filter, all possible
/// decls are returned along with their DeclRelationSets.
/// This is suitable for indexing, where everything is recorded and filtering
/// is applied later.
llvm::SmallVector<std::pair<const NamedDecl *, DeclRelationSet>, 1>
-allTargetDecls(const ast_type_traits::DynTypedNode &);
+allTargetDecls(const DynTypedNode &);
enum class DeclRelation : unsigned {
// Template options apply when the declaration is an instantiated template.
/// ^~~ there is no Decl for 'Ptr<int>', so we return the template pattern.
/// \p Mask should not contain TemplatePattern or TemplateInstantiation.
llvm::SmallVector<const NamedDecl *, 1>
-explicitReferenceTargets(ast_type_traits::DynTypedNode N,
- DeclRelationSet Mask);
+explicitReferenceTargets(DynTypedNode N, DeclRelationSet Mask);
// Boring implementation details of bitfield.
namespace clangd {
namespace {
using Node = SelectionTree::Node;
-using ast_type_traits::DynTypedNode;
// Measure the fraction of selections that were enabled by recovery AST.
void recordMetrics(const SelectionTree &S, const LangOptions &Lang) {
// Direct children within the selection tree.
llvm::SmallVector<const Node *> Children;
// The corresponding node from the full AST.
- ast_type_traits::DynTypedNode ASTNode;
+ DynTypedNode ASTNode;
// The extent to which this node is covered by the selection.
Selection Selected;
// Walk up the AST to get the DeclContext of this Node,
// or the function decl to be selected. Returns null if none of the above
// criteria is met.
const FunctionDecl *getSelectedFunction(const SelectionTree::Node *SelNode) {
- const ast_type_traits::DynTypedNode &AstNode = SelNode->ASTNode;
+ const DynTypedNode &AstNode = SelNode->ASTNode;
if (const FunctionDecl *FD = AstNode.get<FunctionDecl>())
return FD;
if (AstNode.get<CompoundStmt>() &&
const FunctionDecl *getSelectedFunction(const SelectionTree::Node *SelNode) {
if (!SelNode)
return nullptr;
- const ast_type_traits::DynTypedNode &AstNode = SelNode->ASTNode;
+ const DynTypedNode &AstNode = SelNode->ASTNode;
if (const FunctionDecl *FD = AstNode.get<FunctionDecl>())
return FD;
if (AstNode.get<CompoundStmt>() &&
EXPECT_EQ(true, cast<SetQuery<bool> >(Q)->Value);
Q = parse("set traversal AsIs");
- ASSERT_TRUE(isa<SetQuery<ast_type_traits::TraversalKind>>(Q));
- EXPECT_EQ(&QuerySession::TK,
- cast<SetQuery<ast_type_traits::TraversalKind>>(Q)->Var);
- EXPECT_EQ(ast_type_traits::TK_AsIs,
- cast<SetQuery<ast_type_traits::TraversalKind>>(Q)->Value);
+ ASSERT_TRUE(isa<SetQuery<TraversalKind>>(Q));
+ EXPECT_EQ(&QuerySession::TK, cast<SetQuery<TraversalKind>>(Q)->Var);
+ EXPECT_EQ(TK_AsIs, cast<SetQuery<TraversalKind>>(Q)->Value);
Q = parse("set traversal NotATraversal");
ASSERT_TRUE(isa<InvalidQuery>(Q));
return Copy;
}
-DynTypedMatcher
-DynTypedMatcher::withTraversalKind(ast_type_traits::TraversalKind TK) {
+DynTypedMatcher DynTypedMatcher::withTraversalKind(TraversalKind TK) {
auto Copy = *this;
Copy.Implementation =
new DynTraversalMatcherImpl(TK, std::move(Copy.Implementation));
#include <utility>
#include <vector>
-using namespace clang::ast_type_traits;
-
namespace clang {
namespace ast_matchers {
namespace dynamic {
hasType(nonConstReferenceType())))));
const auto Matches = match(
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
findAll(stmt(anyOf(AsAssignmentLhs, AsIncDecOperand,
AsNonConstThis, AsAmpersandOperand,
AsPointerFromArrayDecay, AsOperatorArrowThis,
const auto FuncDecl = hasDeclaration(functionDecl().bind("func"));
const auto Matches = match(
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
findAll(
expr(anyOf(callExpr(NonConstRefParam, IsInstantiated, FuncDecl,
unless(callee(namedDecl(hasAnyName(
static std::vector<DynTypedMatcher> taggedMatchers(
StringRef TagBase,
const SmallVectorImpl<std::pair<size_t, RewriteRule::Case>> &Cases,
- ast_type_traits::TraversalKind DefaultTraversalKind) {
+ TraversalKind DefaultTraversalKind) {
std::vector<DynTypedMatcher> Matchers;
Matchers.reserve(Cases.size());
for (const auto &Case : Cases) {
testImport(
"void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }",
Lang_C99, "", Lang_C99, Verifier,
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
functionDecl(hasDescendant(varDecl(
hasName("C"), hasType(asString("int")),
hasInitializer(stmtExpr(
testImport(
"void declToImport() { (void)(1 ?: -5); }", Lang_CXX03, "", Lang_CXX03,
Verifier,
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
functionDecl(hasDescendant(binaryConditionalOperator(
hasCondition(implicitCastExpr(
hasSourceExpression(opaqueValueExpr(
"struct C {};"
"void declToImport() { C c = C(); }",
Lang_CXX03, "", Lang_CXX03, Verifier,
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
functionDecl(hasDescendant(exprWithCleanups(has(cxxConstructExpr(
has(materializeTemporaryExpr(has(implicitCastExpr(
has(cxxTemporaryObjectExpr()))))))))))));
"template <int K> using dummy2 = dummy<K>;"
"int declToImport() { return dummy2<3>::i; }",
Lang_CXX11, "", Lang_CXX11, Verifier,
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
functionDecl(hasDescendant(implicitCastExpr(has(declRefExpr()))),
unless(hasAncestor(
translationUnitDecl(has(typeAliasDecl())))))));
"};"
"int declToImport() { return dummy<int>::i; }",
Lang_CXX11, "", Lang_CXX11, Verifier,
- traverse(ast_type_traits::TK_AsIs,
- functionDecl(hasDescendant(returnStmt(
- has(implicitCastExpr(has(declRefExpr()))))))));
+ traverse(TK_AsIs, functionDecl(hasDescendant(returnStmt(has(
+ implicitCastExpr(has(declRefExpr()))))))));
}
const internal::VariadicDynCastAllOfMatcher<Type,
"}",
Lang_CXX11, "", Lang_CXX11, Verifier,
traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
functionDecl(
hasDescendant(varDecl(hasName("a"), hasInitializer(hasDescendant(
cxxTypeidExpr())))),
using namespace clang::ast_matchers;
namespace clang {
-namespace ast_type_traits {
+namespace {
TEST(ASTNodeKind, NoKind) {
EXPECT_FALSE(ASTNodeKind().isBaseOf(ASTNodeKind()));
EXPECT_FALSE(Node < Node);
}
-} // namespace ast_type_traits
+} // namespace
} // namespace clang
"+ (void) f1: (A)arg;\n"
"@end\n"
"void f2() { A a; [B f1: (a)]; }\n",
- traverse(ast_type_traits::TK_AsIs, parenExpr()),
- Lang_OBJCXX));
+ traverse(TK_AsIs, parenExpr()), Lang_OBJCXX));
}
TEST(FunctionDecl, FunctionDeclWithThrowSpecification) {
}
TEST(StmtPrinter, TestCXXConversionDeclImplicit) {
- ASSERT_TRUE(
- PrintedStmtCXXMatches(StdVer::CXX98,
- "struct A {"
- "operator void *();"
- "A operator&(A);"
- "};"
- "void bar(void *);"
- "void foo(A a, A b) {"
- " bar(a & b);"
- "}",
- traverse(ast_type_traits::TK_AsIs,
- cxxMemberCallExpr(anything()).bind("id")),
- "a & b"));
+ ASSERT_TRUE(PrintedStmtCXXMatches(
+ StdVer::CXX98,
+ "struct A {"
+ "operator void *();"
+ "A operator&(A);"
+ "};"
+ "void bar(void *);"
+ "void foo(A a, A b) {"
+ " bar(a & b);"
+ "}",
+ traverse(TK_AsIs, cxxMemberCallExpr(anything()).bind("id")), "a & b"));
}
TEST(StmtPrinter, TestCXXConversionDeclExplicit) {
TEST_P(ASTMatchersTest, HasCastKind) {
EXPECT_TRUE(
matches("char *p = 0;",
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
varDecl(has(castExpr(hasCastKind(CK_NullToPointer)))))));
EXPECT_TRUE(notMatches(
"char *p = 0;",
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
varDecl(has(castExpr(hasCastKind(CK_DerivedToBase)))))));
- EXPECT_TRUE(matches(
- "char *p = 0;",
- traverse(ast_type_traits::TK_AsIs,
- varDecl(has(implicitCastExpr(hasCastKind(CK_NullToPointer)))))));
+ EXPECT_TRUE(matches("char *p = 0;",
+ traverse(TK_AsIs, varDecl(has(implicitCastExpr(
+ hasCastKind(CK_NullToPointer)))))));
}
TEST_P(ASTMatchersTest, HasDescendant) {
}
auto Constructor = traverse(
- ast_type_traits::TK_AsIs,
+ TK_AsIs,
cxxConstructExpr(hasArgument(0, declRefExpr(to(varDecl(hasName("y")))))));
EXPECT_TRUE(matches(
"class X { public: X(int); }; void x() { int z; X x(z); }", Constructor));
StatementMatcher WrongIndex =
- traverse(ast_type_traits::TK_AsIs,
- cxxConstructExpr(
- hasArgument(42, declRefExpr(to(varDecl(hasName("y")))))));
+ traverse(TK_AsIs, cxxConstructExpr(hasArgument(
+ 42, declRefExpr(to(varDecl(hasName("y")))))));
EXPECT_TRUE(notMatches(
"class X { public: X(int); }; void x() { int y; X x(y); }", WrongIndex));
}
}
auto Constructor1Arg =
- traverse(ast_type_traits::TK_AsIs, cxxConstructExpr(argumentCountIs(1)));
+ traverse(TK_AsIs, cxxConstructExpr(argumentCountIs(1)));
EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x(0); }",
Constructor1Arg));
}
auto ConstructorListInit =
- traverse(ast_type_traits::TK_AsIs,
- varDecl(has(cxxConstructExpr(isListInitialization()))));
+ traverse(TK_AsIs, varDecl(has(cxxConstructExpr(isListInitialization()))));
EXPECT_TRUE(matches("class X { public: X(int); }; void x() { X x{0}; }",
ConstructorListInit));
return;
}
- StatementMatcher MethodOnY =
- traverse(ast_type_traits::TK_AsIs,
- cxxMemberCallExpr(thisPointerType(recordDecl(hasName("Y")))));
+ StatementMatcher MethodOnY = traverse(
+ TK_AsIs, cxxMemberCallExpr(thisPointerType(recordDecl(hasName("Y")))));
EXPECT_TRUE(matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
MethodOnY));
return;
}
- StatementMatcher Constructor =
- traverse(ast_type_traits::TK_AsIs, cxxConstructExpr());
+ StatementMatcher Constructor = traverse(TK_AsIs, cxxConstructExpr());
EXPECT_TRUE(
matches("class X { public: X(); }; void x() { X x; }", Constructor));
return;
}
- StatementMatcher TempExpression =
- traverse(ast_type_traits::TK_AsIs, cxxBindTemporaryExpr());
+ StatementMatcher TempExpression = traverse(TK_AsIs, cxxBindTemporaryExpr());
StringRef ClassString = "class string { public: string(); ~string(); }; ";
}
StatementMatcher TempExpression =
- traverse(ast_type_traits::TK_AsIs, materializeTemporaryExpr());
+ traverse(TK_AsIs, materializeTemporaryExpr());
EXPECT_TRUE(matches("class string { public: string(); }; "
"string GetStringByValue();"
StringRef ClassString = "class string { public: string(); int length(); }; ";
StatementMatcher TempExpression =
- traverse(ast_type_traits::TK_AsIs, materializeTemporaryExpr());
+ traverse(TK_AsIs, materializeTemporaryExpr());
EXPECT_TRUE(notMatches(ClassString +
"string* GetStringPointer(); "
return;
}
- StatementMatcher AlwaysOne =
- traverse(ast_type_traits::TK_AsIs,
- binaryConditionalOperator(
+ StatementMatcher AlwaysOne = traverse(
+ TK_AsIs, binaryConditionalOperator(
hasCondition(implicitCastExpr(has(opaqueValueExpr(
hasSourceExpression((integerLiteral(equals(1)))))))),
hasFalseExpression(integerLiteral(equals(0)))));
TEST_P(ASTMatchersTest, CastExpression_MatchesImplicitCasts) {
// This test creates an implicit cast from int to char.
- EXPECT_TRUE(
- matches("char c = 0;", traverse(ast_type_traits::TK_AsIs, castExpr())));
+ EXPECT_TRUE(matches("char c = 0;", traverse(TK_AsIs, castExpr())));
// This test creates an implicit cast from lvalue to rvalue.
EXPECT_TRUE(matches("void f() { char c = 0, d = c; }",
- traverse(ast_type_traits::TK_AsIs, castExpr())));
+ traverse(TK_AsIs, castExpr())));
}
TEST_P(ASTMatchersTest, CastExpr_DoesNotMatchNonCasts) {
TEST_P(ASTMatchersTest, ImplicitCastExpr_MatchesSimpleCase) {
// This test creates an implicit const cast.
- EXPECT_TRUE(matches("void f() { int x = 0; const int y = x; }",
- traverse(ast_type_traits::TK_AsIs,
- varDecl(hasInitializer(implicitCastExpr())))));
+ EXPECT_TRUE(
+ matches("void f() { int x = 0; const int y = x; }",
+ traverse(TK_AsIs, varDecl(hasInitializer(implicitCastExpr())))));
// This test creates an implicit cast from int to char.
- EXPECT_TRUE(matches("char c = 0;",
- traverse(ast_type_traits::TK_AsIs,
- varDecl(hasInitializer(implicitCastExpr())))));
+ EXPECT_TRUE(
+ matches("char c = 0;",
+ traverse(TK_AsIs, varDecl(hasInitializer(implicitCastExpr())))));
// This test creates an implicit array-to-pointer cast.
- EXPECT_TRUE(matches("int arr[6]; int *p = arr;",
- traverse(ast_type_traits::TK_AsIs,
- varDecl(hasInitializer(implicitCastExpr())))));
+ EXPECT_TRUE(
+ matches("int arr[6]; int *p = arr;",
+ traverse(TK_AsIs, varDecl(hasInitializer(implicitCastExpr())))));
}
TEST_P(ASTMatchersTest, ImplicitCastExpr_DoesNotMatchIncorrectly) {
if (!GetParam().isCXX()) {
return;
}
- EXPECT_TRUE(matches("struct Foo { ~Foo(); };"
- "const Foo f = Foo();",
- traverse(ast_type_traits::TK_AsIs,
- varDecl(hasInitializer(exprWithCleanups())))));
- EXPECT_FALSE(matches("struct Foo { }; Foo a;"
- "const Foo f = a;",
- traverse(ast_type_traits::TK_AsIs,
- varDecl(hasInitializer(exprWithCleanups())))));
+ EXPECT_TRUE(
+ matches("struct Foo { ~Foo(); };"
+ "const Foo f = Foo();",
+ traverse(TK_AsIs, varDecl(hasInitializer(exprWithCleanups())))));
+ EXPECT_FALSE(
+ matches("struct Foo { }; Foo a;"
+ "const Foo f = a;",
+ traverse(TK_AsIs, varDecl(hasInitializer(exprWithCleanups())))));
}
TEST_P(ASTMatchersTest, InitListExpr) {
"struct A {"
" A(std::initializer_list<int>) {}"
"};";
- EXPECT_TRUE(
- matches(code + "A a{0};",
- traverse(ast_type_traits::TK_AsIs,
- cxxConstructExpr(has(cxxStdInitializerListExpr()),
- hasDeclaration(cxxConstructorDecl(
- ofClass(hasName("A"))))))));
- EXPECT_TRUE(
- matches(code + "A a = {0};",
- traverse(ast_type_traits::TK_AsIs,
- cxxConstructExpr(has(cxxStdInitializerListExpr()),
- hasDeclaration(cxxConstructorDecl(
- ofClass(hasName("A"))))))));
+ EXPECT_TRUE(matches(
+ code + "A a{0};",
+ traverse(TK_AsIs, cxxConstructExpr(has(cxxStdInitializerListExpr()),
+ hasDeclaration(cxxConstructorDecl(
+ ofClass(hasName("A"))))))));
+ EXPECT_TRUE(matches(
+ code + "A a = {0};",
+ traverse(TK_AsIs, cxxConstructExpr(has(cxxStdInitializerListExpr()),
+ hasDeclaration(cxxConstructorDecl(
+ ofClass(hasName("A"))))))));
EXPECT_TRUE(notMatches("int a[] = { 1, 2 };", cxxStdInitializerListExpr()));
EXPECT_TRUE(notMatches("struct B { int x, y; }; B b = { 5, 6 };",
}
TEST_P(ASTMatchersTest, ParenExpr_SimpleCases) {
- EXPECT_TRUE(
- matches("int i = (3);", traverse(ast_type_traits::TK_AsIs, parenExpr())));
- EXPECT_TRUE(matches("int i = (3 + 7);",
- traverse(ast_type_traits::TK_AsIs, parenExpr())));
- EXPECT_TRUE(notMatches("int i = 3;",
- traverse(ast_type_traits::TK_AsIs, parenExpr())));
+ EXPECT_TRUE(matches("int i = (3);", traverse(TK_AsIs, parenExpr())));
+ EXPECT_TRUE(matches("int i = (3 + 7);", traverse(TK_AsIs, parenExpr())));
+ EXPECT_TRUE(notMatches("int i = 3;", traverse(TK_AsIs, parenExpr())));
EXPECT_TRUE(notMatches("int f() { return 1; }; void g() { int a = f(); }",
- traverse(ast_type_traits::TK_AsIs, parenExpr())));
+ traverse(TK_AsIs, parenExpr())));
}
TEST_P(ASTMatchersTest, IgnoringParens) {
- EXPECT_FALSE(matches(
- "const char* str = (\"my-string\");",
- traverse(ast_type_traits::TK_AsIs,
- implicitCastExpr(hasSourceExpression(stringLiteral())))));
- EXPECT_TRUE(matches("const char* str = (\"my-string\");",
- traverse(ast_type_traits::TK_AsIs,
- implicitCastExpr(hasSourceExpression(
- ignoringParens(stringLiteral()))))));
+ EXPECT_FALSE(matches("const char* str = (\"my-string\");",
+ traverse(TK_AsIs, implicitCastExpr(hasSourceExpression(
+ stringLiteral())))));
+ EXPECT_TRUE(
+ matches("const char* str = (\"my-string\");",
+ traverse(TK_AsIs, implicitCastExpr(hasSourceExpression(
+ ignoringParens(stringLiteral()))))));
}
TEST_P(ASTMatchersTest, QualType) {
EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX));
EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX));
- CallMethodX =
- traverse(ast_type_traits::TK_AsIs, callExpr(callee(cxxConversionDecl())));
+ CallMethodX = traverse(TK_AsIs, callExpr(callee(cxxConversionDecl())));
EXPECT_TRUE(
matches("struct Y { operator int() const; }; int i = Y();", CallMethodX));
EXPECT_TRUE(notMatches("struct Y { operator int() const; }; Y y = Y();",
"void x() { int y; (void)Y(1, 2); }",
UnresolvedCtorArgumentY));
- StatementMatcher ImplicitCastedArgument = traverse(
- ast_type_traits::TK_AsIs, callExpr(hasAnyArgument(implicitCastExpr())));
+ StatementMatcher ImplicitCastedArgument =
+ traverse(TK_AsIs, callExpr(hasAnyArgument(implicitCastExpr())));
EXPECT_TRUE(matches("void x(long) { int y; x(y); }", ImplicitCastedArgument));
}
struct X : public Y {};
void z(X x) { x.m(); }
)cc";
- auto MatchesY = traverse(ast_type_traits::TK_AsIs,
- cxxMemberCallExpr(onImplicitObjectArgument(
- hasType(cxxRecordDecl(hasName("Y"))))));
+ auto MatchesY = traverse(TK_AsIs, cxxMemberCallExpr(onImplicitObjectArgument(
+ hasType(cxxRecordDecl(hasName("Y"))))));
EXPECT_TRUE(matches(Snippet1, MatchesY));
EXPECT_TRUE(matches(Snippet2, MatchesY));
- auto MatchesX = traverse(ast_type_traits::TK_AsIs,
- cxxMemberCallExpr(onImplicitObjectArgument(
- hasType(cxxRecordDecl(hasName("X"))))));
+ auto MatchesX = traverse(TK_AsIs, cxxMemberCallExpr(onImplicitObjectArgument(
+ hasType(cxxRecordDecl(hasName("X"))))));
EXPECT_TRUE(notMatches(Snippet2, MatchesX));
// Parens are not ignored.
Y g();
void z(Y y) { (g()).m(); }
)cc";
- auto MatchesCall =
- traverse(ast_type_traits::TK_AsIs,
- cxxMemberCallExpr(onImplicitObjectArgument(callExpr())));
+ auto MatchesCall = traverse(
+ TK_AsIs, cxxMemberCallExpr(onImplicitObjectArgument(callExpr())));
EXPECT_TRUE(notMatches(Snippet3, MatchesCall));
}
StatementMatcher ArgumentY =
declRefExpr(to(varDecl(hasName("y")))).bind("arg");
DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
- StatementMatcher ConstructExpr =
- traverse(ast_type_traits::TK_AsIs,
- cxxConstructExpr(forEachArgumentWithParam(ArgumentY, IntParam)));
+ StatementMatcher ConstructExpr = traverse(
+ TK_AsIs, cxxConstructExpr(forEachArgumentWithParam(ArgumentY, IntParam)));
EXPECT_TRUE(matchAndVerifyResultTrue(
"struct C {"
EXPECT_TRUE(matches("void x() { true && false; }", OperatorTrueFalse));
EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse));
- StatementMatcher OperatorIntPointer =
- arraySubscriptExpr(hasLHS(hasType(isInteger())),
- traverse(ast_type_traits::TK_AsIs,
- hasRHS(hasType(pointsTo(qualType())))));
+ StatementMatcher OperatorIntPointer = arraySubscriptExpr(
+ hasLHS(hasType(isInteger())),
+ traverse(TK_AsIs, hasRHS(hasType(pointsTo(qualType())))));
EXPECT_TRUE(matches("void x() { 1[\"abc\"]; }", OperatorIntPointer));
EXPECT_TRUE(notMatches("void x() { \"abc\"[1]; }", OperatorIntPointer));
}
}
TEST(ArraySubscriptMatchers, MatchesArrayBase) {
- EXPECT_TRUE(matches("int i[2]; void f() { i[1] = 2; }",
- traverse(ast_type_traits::TK_AsIs,
- arraySubscriptExpr(hasBase(implicitCastExpr(
- hasSourceExpression(declRefExpr())))))));
+ EXPECT_TRUE(
+ matches("int i[2]; void f() { i[1] = 2; }",
+ traverse(TK_AsIs, arraySubscriptExpr(hasBase(implicitCastExpr(
+ hasSourceExpression(declRefExpr())))))));
}
TEST(Matcher, OfClass) {
// This test creates an implicit const cast.
EXPECT_TRUE(matches(
"int x; const int i = x;",
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
implicitCastExpr(hasImplicitDestinationType(isInteger())))));
// This test creates an implicit array-to-pointer cast.
- EXPECT_TRUE(matches("int arr[3]; int *p = arr;",
- traverse(ast_type_traits::TK_AsIs,
- implicitCastExpr(hasImplicitDestinationType(
- pointsTo(TypeMatcher(anything())))))));
+ EXPECT_TRUE(
+ matches("int arr[3]; int *p = arr;",
+ traverse(TK_AsIs, implicitCastExpr(hasImplicitDestinationType(
+ pointsTo(TypeMatcher(anything())))))));
}
TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) {
)";
EXPECT_TRUE(matches(
Code,
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
varDecl(hasName("i"),
hasInitializer(exprWithCleanups(has(cxxConstructExpr(
has(expr(ignoringImplicit(cxxConstructExpr(has(
}
TEST(IgnoringImplicit, DoesNotMatchIncorrectly) {
- EXPECT_TRUE(notMatches(
- "class C {}; C a = C();",
- traverse(ast_type_traits::TK_AsIs, varDecl(has(cxxConstructExpr())))));
+ EXPECT_TRUE(notMatches("class C {}; C a = C();",
+ traverse(TK_AsIs, varDecl(has(cxxConstructExpr())))));
}
TEST(Traversal, traverseMatcher) {
integerLiteral())))));
EXPECT_TRUE(notMatches(
"int i = (0);",
- traverse(ast_type_traits::TK_AsIs,
+ traverse(TK_AsIs,
varDecl(hasInitializer(ignoringImpCasts(integerLiteral()))))));
EXPECT_TRUE(notMatches("float i = (float)0;",
varDecl(hasInitializer(ignoringImpCasts(
}
TEST(HasSourceExpression, MatchesImplicitCasts) {
- EXPECT_TRUE(matches(
- "class string {}; class URL { public: URL(string s); };"
- "void r() {string a_string; URL url = a_string; }",
- traverse(ast_type_traits::TK_AsIs,
- implicitCastExpr(hasSourceExpression(cxxConstructExpr())))));
+ EXPECT_TRUE(matches("class string {}; class URL { public: URL(string s); };"
+ "void r() {string a_string; URL url = a_string; }",
+ traverse(TK_AsIs, implicitCastExpr(hasSourceExpression(
+ cxxConstructExpr())))));
}
TEST(HasSourceExpression, MatchesExplicitCasts) {
- EXPECT_TRUE(matches("float x = static_cast<float>(42);",
- traverse(ast_type_traits::TK_AsIs,
- explicitCastExpr(hasSourceExpression(
- hasDescendant(expr(integerLiteral())))))));
+ EXPECT_TRUE(
+ matches("float x = static_cast<float>(42);",
+ traverse(TK_AsIs, explicitCastExpr(hasSourceExpression(
+ hasDescendant(expr(integerLiteral())))))));
}
TEST(UsingDeclaration, MatchesSpecificTarget) {
EXPECT_TRUE(notMatches(
"void x() { if (1) switch(42) { case 42: switch (42) { default:; } } }",
ifStmt(has(switchStmt(forEachSwitchCase(defaultStmt()))))));
- EXPECT_TRUE(
- matches("void x() { switch(42) { case 1+1: case 4:; } }",
- traverse(ast_type_traits::TK_AsIs,
- switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
- constantExpr(has(integerLiteral())))))))));
- EXPECT_TRUE(
- notMatches("void x() { switch(42) { case 1+1: case 2+2:; } }",
- traverse(ast_type_traits::TK_AsIs,
- switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
- constantExpr(has(integerLiteral())))))))));
- EXPECT_TRUE(
- notMatches("void x() { switch(42) { case 1 ... 2:; } }",
- traverse(ast_type_traits::TK_AsIs,
- switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
- constantExpr(has(integerLiteral())))))))));
+ EXPECT_TRUE(matches(
+ "void x() { switch(42) { case 1+1: case 4:; } }",
+ traverse(TK_AsIs, switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
+ constantExpr(has(integerLiteral())))))))));
+ EXPECT_TRUE(notMatches(
+ "void x() { switch(42) { case 1+1: case 2+2:; } }",
+ traverse(TK_AsIs, switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
+ constantExpr(has(integerLiteral())))))))));
+ EXPECT_TRUE(notMatches(
+ "void x() { switch(42) { case 1 ... 2:; } }",
+ traverse(TK_AsIs, switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
+ constantExpr(has(integerLiteral())))))))));
EXPECT_TRUE(matchAndVerifyResultTrue(
"void x() { switch (42) { case 1: case 2: case 3: default:; } }",
switchStmt(forEachSwitchCase(caseStmt().bind("x"))),
cxxConversionDecl(
hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
langCxx20OrLater()));
- EXPECT_TRUE(matches("struct S { explicit(true) operator int(); };",
- traverse(ast_type_traits::TK_AsIs,
- cxxConversionDecl(hasExplicitSpecifier(
- constantExpr(has(cxxBoolLiteral()))))),
- langCxx20OrLater()));
- EXPECT_TRUE(matches("struct S { explicit(false) operator int(); };",
- traverse(ast_type_traits::TK_AsIs,
- cxxConversionDecl(hasExplicitSpecifier(
- constantExpr(has(cxxBoolLiteral()))))),
- langCxx20OrLater()));
- EXPECT_TRUE(notMatches("template<bool b> struct S { explicit(b) S(int); };",
- traverse(ast_type_traits::TK_AsIs,
- cxxConstructorDecl(hasExplicitSpecifier(
- constantExpr(has(cxxBoolLiteral()))))),
- langCxx20OrLater()));
- EXPECT_TRUE(matches("struct S { explicit(true) S(int); };",
- traverse(ast_type_traits::TK_AsIs,
- cxxConstructorDecl(hasExplicitSpecifier(
- constantExpr(has(cxxBoolLiteral()))))),
- langCxx20OrLater()));
- EXPECT_TRUE(matches("struct S { explicit(false) S(int); };",
- traverse(ast_type_traits::TK_AsIs,
- cxxConstructorDecl(hasExplicitSpecifier(
- constantExpr(has(cxxBoolLiteral()))))),
- langCxx20OrLater()));
+ EXPECT_TRUE(
+ matches("struct S { explicit(true) operator int(); };",
+ traverse(TK_AsIs, cxxConversionDecl(hasExplicitSpecifier(
+ constantExpr(has(cxxBoolLiteral()))))),
+ langCxx20OrLater()));
+ EXPECT_TRUE(
+ matches("struct S { explicit(false) operator int(); };",
+ traverse(TK_AsIs, cxxConversionDecl(hasExplicitSpecifier(
+ constantExpr(has(cxxBoolLiteral()))))),
+ langCxx20OrLater()));
+ EXPECT_TRUE(
+ notMatches("template<bool b> struct S { explicit(b) S(int); };",
+ traverse(TK_AsIs, cxxConstructorDecl(hasExplicitSpecifier(
+ constantExpr(has(cxxBoolLiteral()))))),
+ langCxx20OrLater()));
+ EXPECT_TRUE(
+ matches("struct S { explicit(true) S(int); };",
+ traverse(TK_AsIs, cxxConstructorDecl(hasExplicitSpecifier(
+ constantExpr(has(cxxBoolLiteral()))))),
+ langCxx20OrLater()));
+ EXPECT_TRUE(
+ matches("struct S { explicit(false) S(int); };",
+ traverse(TK_AsIs, cxxConstructorDecl(hasExplicitSpecifier(
+ constantExpr(has(cxxBoolLiteral()))))),
+ langCxx20OrLater()));
EXPECT_TRUE(
notMatches("template<typename T> struct S { S(int); };"
"template<bool b = true> explicit(b) S(int) -> S<int>;",
- traverse(ast_type_traits::TK_AsIs,
- cxxDeductionGuideDecl(hasExplicitSpecifier(
- constantExpr(has(cxxBoolLiteral()))))),
+ traverse(TK_AsIs, cxxDeductionGuideDecl(hasExplicitSpecifier(
+ constantExpr(has(cxxBoolLiteral()))))),
langCxx20OrLater()));
- EXPECT_TRUE(matches("template<typename T> struct S { S(int); };"
- "explicit(true) S(int) -> S<int>;",
- traverse(ast_type_traits::TK_AsIs,
- cxxDeductionGuideDecl(hasExplicitSpecifier(
- constantExpr(has(cxxBoolLiteral()))))),
- langCxx20OrLater()));
- EXPECT_TRUE(matches("template<typename T> struct S { S(int); };"
- "explicit(false) S(int) -> S<int>;",
- traverse(ast_type_traits::TK_AsIs,
- cxxDeductionGuideDecl(hasExplicitSpecifier(
- constantExpr(has(cxxBoolLiteral()))))),
- langCxx20OrLater()));
+ EXPECT_TRUE(
+ matches("template<typename T> struct S { S(int); };"
+ "explicit(true) S(int) -> S<int>;",
+ traverse(TK_AsIs, cxxDeductionGuideDecl(hasExplicitSpecifier(
+ constantExpr(has(cxxBoolLiteral()))))),
+ langCxx20OrLater()));
+ EXPECT_TRUE(
+ matches("template<typename T> struct S { S(int); };"
+ "explicit(false) S(int) -> S<int>;",
+ traverse(TK_AsIs, cxxDeductionGuideDecl(hasExplicitSpecifier(
+ constantExpr(has(cxxBoolLiteral()))))),
+ langCxx20OrLater()));
}
TEST(ForEachConstructorInitializer, MatchesInitializers) {
TEST_F(RegistryTest, ParenExpr) {
Matcher<Stmt> Value = constructMatcher("parenExpr").getTypedMatcher<Stmt>();
- EXPECT_TRUE(
- matches("int i = (1);", traverse(ast_type_traits::TK_AsIs, Value)));
- EXPECT_FALSE(
- matches("int i = 1;", traverse(ast_type_traits::TK_AsIs, Value)));
+ EXPECT_TRUE(matches("int i = (1);", traverse(TK_AsIs, Value)));
+ EXPECT_FALSE(matches("int i = 1;", traverse(TK_AsIs, Value)));
}
TEST_F(RegistryTest, EqualsMatcher) {
bool isMutated(const SmallVectorImpl<BoundNodes> &Results, ASTUnit *AST) {
const auto *const S = selectFirst<Stmt>("stmt", Results);
const auto *const E = selectFirst<Expr>("expr", Results);
- TraversalKindScope RAII(AST->getASTContext(), ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(AST->getASTContext(), TK_AsIs);
return ExprMutationAnalyzer(*S, AST->getASTContext()).isMutated(E);
}
ASTContext &Context = ASTUnit->getASTContext();
assert(!Context.getDiagnostics().hasErrorOccurred() && "Compilation error");
- TraversalKindScope RAII(Context, ast_type_traits::TK_AsIs);
+ TraversalKindScope RAII(Context, TK_AsIs);
auto Matches = ast_matchers::match(Matcher, Context);
// We expect a single, exact match.
assert(Matches.size() != 0 && "no matches found");
const T &AMatcher, RefactoringCallback &Callback) {
std::map<std::string, Replacements> FileToReplace;
ASTMatchRefactorer Finder(FileToReplace);
- Finder.addMatcher(traverse(ast_type_traits::TK_AsIs, AMatcher), &Callback);
+ Finder.addMatcher(traverse(TK_AsIs, AMatcher), &Callback);
std::unique_ptr<tooling::FrontendActionFactory> Factory(
tooling::newFrontendActionFactory(&Finder));
ASSERT_TRUE(tooling::runToolOnCode(Factory->create(), Code))
Callback.takeError());
}
-
-} // end namespace ast_matchers
+} // namespace tooling
} // end namespace clang
};
)cc";
auto StmtMatch = matchStmt(
- Snippet, traverse(ast_type_traits::TK_AsIs,
- returnStmt(hasReturnValue(ignoringImplicit(memberExpr(
+ Snippet,
+ traverse(TK_AsIs, returnStmt(hasReturnValue(ignoringImplicit(memberExpr(
hasObjectExpression(expr().bind("obj"))))))));
ASSERT_TRUE(StmtMatch);
const Stencil Stencil = access("obj", "field");