Fix Stmt::ignoreImplicit

[steveire]

Summary

A CXXBindTemporaryExpr can appear inside an ImplicitCastExpr, and was
not ignored previously.

Fixes the case reported in PR37327.

[rsmith]

lib/AST/Stmt.cpp

121–122 ↗

(On Diff #160452)

ExprWithCleanups can only appear at the top level. But... maybe it's not worth treating that as a special case.

cfe/trunk/lib/AST/Stmt.cpp

 bool Stmt::StatisticsEnabled = false;
 void Stmt::EnableStatistics() {
   StatisticsEnabled = true;
 }
 
 Stmt *Stmt::IgnoreImplicit() {
   Stmt *s = this;
 
+  Stmt *lasts = nullptr;
+
+  while (s != lasts) {
+    lasts = s;
+
     if (auto *ewc = dyn_cast<ExprWithCleanups>(s))
       s = ewc->getSubExpr();
 
     if (auto *mte = dyn_cast<MaterializeTemporaryExpr>(s))
       s = mte->GetTemporaryExpr();
 
     if (auto *bte = dyn_cast<CXXBindTemporaryExpr>(s))
       s = bte->getSubExpr();
 
-  while (auto *ice = dyn_cast<ImplicitCastExpr>(s))
+    if (auto *ice = dyn_cast<ImplicitCastExpr>(s))
       s = ice->getSubExpr();
+  }
 
   return s;
 }
 
 /// Skip no-op (attributed, compound) container stmts and skip captured
 /// stmt at the top, if \a IgnoreCaptured is true.
 Stmt *Stmt::IgnoreContainers(bool IgnoreCaptured) {
   Stmt *S = this;

cfe/trunk/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

EXPECT_TRUE(notMatches("int arr[3]; int *p = arr;",
                            unless(anything())))));
 }
 
 TEST(IgnoringImplicit, MatchesImplicit) {
   EXPECT_TRUE(matches("class C {}; C a = C();",
                       varDecl(has(ignoringImplicit(cxxConstructExpr())))));
 }
 
+TEST(IgnoringImplicit, MatchesNestedImplicit) {
+  EXPECT_TRUE(matches(R"(
+
+struct OtherType;
+
+struct SomeType
+{
+    SomeType() {}
+    SomeType(const OtherType&) {}
+    SomeType& operator=(OtherType const&) { return *this; }
+};
+
+struct OtherType
+{
+    OtherType() {}
+    ~OtherType() {}
+};
+
+OtherType something()
+{
+    return {};
+}
+
+int main()
+{
+    SomeType i = something();
+}
+)"
+  , varDecl(
+      hasName("i"),
+      hasInitializer(exprWithCleanups(has(
+        cxxConstructExpr(has(expr(ignoringImplicit(cxxConstructExpr(
+          has(expr(ignoringImplicit(callExpr())))
+          )))))
+        )))
+      )
+  ));
+}
+
 TEST(IgnoringImplicit, DoesNotMatchIncorrectly) {
   EXPECT_TRUE(
       notMatches("class C {}; C a = C();", varDecl(has(cxxConstructExpr()))));
 }
 
 TEST(IgnoringImpCasts, MatchesImpCasts) {
   // This test checks that ignoringImpCasts matches when implicit casts are
   // present and its inner matcher alone does not match.