diff --git a/include/clang/ASTMatchers/ASTMatchers.h b/include/clang/ASTMatchers/ASTMatchers.h index 2f1555b..ffcd311 100644 --- a/include/clang/ASTMatchers/ASTMatchers.h +++ b/include/clang/ASTMatchers/ASTMatchers.h @@ -185,6 +185,75 @@ AST_MATCHER_P(ClassTemplateSpecializationDecl, hasAnyTemplateArgument, return false; } +/// \brief Matches expressions that match InnerMatcher after any implicit casts +/// are stripped off. +/// +/// Parentheses and explicit casts are not discarded. +/// Given +/// int arr[5]; +/// int a = 0; +/// char b = 0; +/// const int c = a; +/// int *d = arr; +/// long e = (long) 0l; +/// The matchers +/// variable(hasInitializer(ignoringImplicitCasts(integerLiteral()))) +/// variable(hasInitializer(ignoringImplicitCasts(declarationReference()))) +/// would match the declarations for a, b, c, and d, but not e. +/// while +/// variable(hasInitializer(integerLiteral())) +/// variable(hasInitializer(declarationReference())) +/// only match the declarations for b, c, and d. +AST_MATCHER_P(Expr, ignoringImplicitCasts, + internal::Matcher, InnerMatcher) { + return InnerMatcher.matches(*Node.IgnoreImpCasts(), Finder, Builder); +} + +/// \brief Matches expressions that match InnerMatcher after parentheses and +/// casts are stripped off. +/// +/// Implicit and non-C Style casts are not discarded. +/// Given +/// int a = 0; +/// char b = (0); +/// void* c = reinterpret_cast(&c); +/// char d = char(0); +/// The matcher +/// variable(hasInitializer(ignoringParenCasts(integerLiteral()))) +/// would match the declarations for a, b, c, and d. +/// while +/// variable(hasInitializer(integerLiteral())) +/// only match the declaration for a. +AST_MATCHER_P(Expr, ignoringParenCasts, internal::Matcher, InnerMatcher) { + return InnerMatcher.matches(*Node.IgnoreParenCasts(), Finder, Builder); +} + +/// \brief Matches expressions that match InnerMatcher after implicit casts and +/// parentheses are stripped off. +/// +/// Explicit casts are not discarded. +/// Given +/// int arr[5]; +/// int a = 0; +/// char b = (0); +/// const int c = a; +/// int *d = (arr); +/// long e = ((long) 0l); +/// The matchers +/// variable(hasInitializer(ignoringParenAndImplicitCasts( +/// integerLiteral()))) +/// variable(hasInitializer(ignoringParenAndImplicitCasts( +/// declarationReference()))) +/// would match the declarations for a, b, c, and d, but not e. +/// while +/// variable(hasInitializer(integerLiteral())) +/// variable(hasInitializer(declarationReference())) +/// would only match the declaration for a. +AST_MATCHER_P(Expr, ignoringParenAndImplicitCasts, + internal::Matcher, InnerMatcher) { + return InnerMatcher.matches(*Node.IgnoreParenImpCasts(), Finder, Builder); +} + /// \brief Matches classTemplateSpecializations where the n'th TemplateArgument /// matches the given Matcher. /// @@ -673,6 +742,17 @@ const internal::VariadicDynCastAllOfMatcher< Expr, ImplicitCastExpr> implicitCast; +/// \brief Matches any cast nodes of Clang's AST. +/// +/// Example: castExpression() matches each of the following: +/// (int) 3; +/// const_cast(SubExpr); +/// (i); +/// char c = 0; +const internal::VariadicDynCastAllOfMatcher< + Expr, + CastExpr> castExpression; + /// \brief Matches functional cast expressions /// /// Example: Matches Foo(bar); @@ -1597,7 +1677,7 @@ AST_MATCHER_P(UnaryOperator, hasUnaryOperand, InnerMatcher.matches(*Operand, Finder, Builder)); } -/// \brief Matches if the implicit cast's source expression matches the given +/// \brief Matches if the cast's source expression matches the given /// matcher. /// /// Example: matches "a string" (matcher = @@ -1605,7 +1685,7 @@ AST_MATCHER_P(UnaryOperator, hasUnaryOperand, /// /// class URL { URL(string); }; /// URL url = "a string"; -AST_MATCHER_P(ImplicitCastExpr, hasSourceExpression, +AST_MATCHER_P(CastExpr, hasSourceExpression, internal::Matcher, InnerMatcher) { const Expr* const SubExpression = Node.getSubExpr(); return (SubExpression != NULL && @@ -1622,6 +1702,7 @@ AST_MATCHER_P(ExplicitCastExpr, hasDestinationType, return InnerMatcher.matches(NodeType, Finder, Builder); } + /// \brief Matches implicit casts whose destination type matches a given /// matcher. /// diff --git a/unittests/ASTMatchers/ASTMatchersTest.cpp b/unittests/ASTMatchers/ASTMatchersTest.cpp index 75dd12f..c931d52 100644 --- a/unittests/ASTMatchers/ASTMatchersTest.cpp +++ b/unittests/ASTMatchers/ASTMatchersTest.cpp @@ -1970,6 +1970,21 @@ TEST(IsConstQualified, DoesNotMatchInappropriately) { variable(hasType(isConstQualified())))); } +TEST(CastExpression, MatchesSimpleCases) { + EXPECT_TRUE(matches("char *p = reinterpret_cast(&p);", + expression(castExpression()))); + EXPECT_TRUE(matches("void *p = (void *)(&p);", expression(castExpression()))); + EXPECT_TRUE(matches("char q, *p = const_cast(&q);", + expression(castExpression()))); + EXPECT_TRUE(matches("char c = 0;", expression(castExpression()))); + EXPECT_TRUE(matches("char c = char(0);", expression(castExpression()))); +} + +TEST(CastExpression, DoesNotMatchNonCasts) { + EXPECT_TRUE(notMatches("char c = '0';", expression(castExpression()))); + EXPECT_TRUE(notMatches("char c, &q = c;", expression(castExpression()))); +} + TEST(ReinterpretCast, MatchesSimpleCase) { EXPECT_TRUE(matches("char* p = reinterpret_cast(&p);", expression(reinterpretCast()))); @@ -2036,6 +2051,145 @@ TEST(HasDestinationType, MatchesSimpleCase) { pointsTo(TypeMatcher(anything()))))))); } +TEST(HasImplicitDestinationType, MatchesSimpleCase) { + EXPECT_TRUE(matches("int x; const int i = x;", + expression(implicitCast( + hasImplicitDestinationType(isInteger()))))); + EXPECT_TRUE(matches("int arr[3]; int *p = arr;", + expression(implicitCast(hasImplicitDestinationType( + pointsTo(TypeMatcher(anything()))))))); +} + +TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) { + EXPECT_TRUE(notMatches("char c = 0;", + expression(implicitCast(hasImplicitDestinationType( + unless(anything())))))); + EXPECT_TRUE(notMatches("int arr[3]; int *p = arr;", + expression(implicitCast(hasImplicitDestinationType( + unless(anything())))))); +} + +TEST(ImplicitCast, MatchesSimpleCase) { + EXPECT_TRUE(matches("int x = 0; const int y = x;", + variable(hasInitializer(implicitCast(expression()))))); + EXPECT_TRUE(matches("char c = 0;", + variable(hasInitializer(implicitCast(expression()))))); + EXPECT_TRUE(matches("int arr[6]; int *p = arr;", + variable(hasInitializer(implicitCast(expression()))))); +} + +TEST(ImplicitCast, DoesNotMatchIncorrectly) { + EXPECT_TRUE(notMatches("int x = 0;", + variable(hasInitializer(implicitCast(expression()))))); + EXPECT_TRUE(notMatches("int x = 0, &y = x;", + variable(hasInitializer(implicitCast(expression()))))); + EXPECT_TRUE(notMatches("int x = 0; double d = (double) x;", + variable(hasInitializer(implicitCast(expression()))))); + EXPECT_TRUE(notMatches("const int *p; int *q = const_cast(p);", + variable(hasInitializer(implicitCast(expression()))))); +} + +TEST(IgnoringImplicitCasts, MatchesOnlyWithImpCasts) { + EXPECT_TRUE(notMatches("int x = 0; const int y = x;", + variable(hasInitializer(declarationReference())))); + EXPECT_TRUE(matches("int x = 0; const int y = x;", + variable(hasInitializer(ignoringImplicitCasts( + declarationReference()))))); +} + +TEST(IgnoringImplicitCasts, DoesNotMatchIncorrectly) { + EXPECT_TRUE(notMatches("int x; const int y = x;", + variable(hasInitializer(ignoringImplicitCasts( + unless(anything())))))); + + EXPECT_TRUE(notMatches("char* p = static_cast(0);", + variable(hasInitializer(ignoringImplicitCasts( + integerLiteral()))))); +} + +TEST(IgnoringImplicitCasts, MatchesWithAndWithoutImpCasts) { + EXPECT_TRUE(matches("int x = 0; int &y = x;", + variable(hasInitializer(declarationReference())))); + EXPECT_TRUE(matches("int x = 0; int &y = x;", + variable(hasInitializer(ignoringImplicitCasts( + declarationReference()))))); +} + +TEST(IgnoringParenCasts, MatchesOnlyWithParenCasts) { + EXPECT_TRUE(notMatches("int x = (0);", + variable(hasInitializer(integerLiteral(equals(0)))))); + EXPECT_TRUE(matches("int x = (0);", + variable(hasInitializer(ignoringParenCasts( + integerLiteral(equals(0))))))); + EXPECT_TRUE(notMatches("int x = (0);", + variable(hasInitializer(integerLiteral(equals(0)))))); + EXPECT_TRUE(matches("char x = (char)0;", + variable(hasInitializer(ignoringParenCasts( + integerLiteral(equals(0))))))); + EXPECT_TRUE(notMatches("int x = (((((0)))));", + variable(hasInitializer(integerLiteral(equals(0)))))); + EXPECT_TRUE(matches("int x = (((((0)))));", + variable(hasInitializer(ignoringParenCasts( + integerLiteral(equals(0))))))); + EXPECT_TRUE(notMatches("char* p = static_cast(0);", + variable(hasInitializer(integerLiteral(equals(0)))))); + EXPECT_TRUE(matches("char* p = static_cast(0);", + variable(hasInitializer(ignoringParenCasts( + integerLiteral(equals(0))))))); +} + +TEST(IgnoringParenCasts, MatchesWithAndWithoutParenCasts) { + EXPECT_TRUE(matches("int x = 0;", + variable(hasInitializer(integerLiteral(equals(0)))))); + EXPECT_TRUE(matches("int x = 0;", + variable(hasInitializer(ignoringParenCasts( + integerLiteral(equals(0))))))); +} + +TEST(IgnoringParenCasts, DoesNotMatchIncorrectly) { + EXPECT_TRUE(notMatches("int x = ((3));", + variable(hasInitializer(ignoringParenCasts( + unless(anything())))))); +} + +TEST(IgnoringParenAndImpCasts, MatchesOnlyWithParenImpCasts) { + EXPECT_TRUE(notMatches("int x = 0; const int y = x;", + variable(hasInitializer(declarationReference())))); + EXPECT_TRUE(matches("int x = 0; const int y = x;", + variable(hasInitializer(ignoringParenAndImplicitCasts( + declarationReference()))))); + EXPECT_TRUE(notMatches("const int x = (0);", + variable(hasInitializer(integerLiteral(equals(0)))))); + EXPECT_TRUE(matches("const int x = (0);", + variable(hasInitializer(ignoringParenAndImplicitCasts( + integerLiteral(equals(0))))))); +} + +TEST(IgnoringParenAndImpCasts, MatchesWithAndWithoutParenImpCasts) { + EXPECT_TRUE(matches("int x = 0; int &y = x;", + variable(hasInitializer(ignoringParenAndImplicitCasts( + declarationReference()))))); + EXPECT_TRUE(matches("int x = 0; int &y = x;", + variable(hasInitializer(declarationReference())))); + EXPECT_TRUE(matches("int x = 0;", + variable(hasInitializer(integerLiteral(equals(0)))))); + EXPECT_TRUE(matches("int x = 0;", + variable(hasInitializer(ignoringParenAndImplicitCasts( + integerLiteral(equals(0))))))); +} + +TEST(IgnoringParenAndImpCasts, DoesNotMatchIncorrectly) { + EXPECT_TRUE(notMatches("char c = ((3));", + variable(hasInitializer(ignoringParenAndImplicitCasts( + unless(anything())))))); + EXPECT_TRUE(notMatches("float y = (float(0));", + variable(hasInitializer(ignoringParenAndImplicitCasts( + integerLiteral()))))); + EXPECT_TRUE(notMatches("char* p = static_cast(0);", + variable(hasInitializer(ignoringParenAndImplicitCasts( + integerLiteral()))))); +} + TEST(HasSourceExpression, MatchesSimpleCase) { EXPECT_TRUE(matches("class string {}; class URL { public: URL(string s); };" "void r() {string a_string; URL url = a_string; }",