Add method to ignore invisible AST nodes

[aaron.ballman]

clang/include/clang/AST/Expr.h

769–770

Invisible is a bit of an odd term because the AST nodes themselves are in fact visible within the AST. I think this means "invisible" as in "not corresponding directly to syntax the user wrote". Bikeshedding some other names:

• IgnoreAllImplicitExprs
• IgnoreAllImplicitNodes
• IgnoreNodesNotWrittenByUser
• IgnoreNotWrittenInSource

other suggestions welcome.

clang/lib/AST/Expr.cpp

3024–3026

Can remove the spurious newline, and these should be named according to the usual naming conventions (I'd go with E and LastE, but feel free to pick less terrible names).

3032

Drop top-level const (I wouldn't be sad if it also lost the auto at the same time).

3034

const auto *

3036

const Expr *

3037

!isa<CXXTemporaryObjectExpr>(C) since you're not using the returned value anyway.

3042

const auto *

3043

const Expr *

Are you sure you mean to skip parens here, as those are written in source?

3044

Elide braces

[steveire]

Update

[steveire]

It wasn't possible to add the const because of the return type.

clang/include/clang/AST/Expr.h

769–770

Changed as discussed on IRC.

[aaron.ballman]

LGTM

clang/include/clang/AST/ASTNodeTraverser.h

getNodeDelegate().AddChild(Label, [=] {
 
       if (auto *E = dyn_cast_or_null<Expr>(S)) {
         switch (Traversal) {
         case ast_type_traits::TK_AsIs:
           break;
         case ast_type_traits::TK_IgnoreImplicitCastsAndParentheses:
           S = E->IgnoreParenImpCasts();
           break;
+        case ast_type_traits::TK_IgnoreUnlessSpelledInSource:
+          S = E->IgnoreUnlessSpelledInSource();
+          break;
         }
       }
 
       getNodeDelegate().Visit(S);
 
       if (!S) {
         return;
       }

clang/include/clang/AST/ASTTypeTraits.h

 /// Defines how we descend a level in the AST when we pass
 /// through expressions.
 enum TraversalKind {
   /// Will traverse all child nodes.
   TK_AsIs,
 
   /// Will not traverse implicit casts and parentheses.
   /// Corresponds to Expr::IgnoreParenImpCasts()
-  TK_IgnoreImplicitCastsAndParentheses
+  TK_IgnoreImplicitCastsAndParentheses,
+
+  /// Ignore AST nodes not written in the source
+  TK_IgnoreUnlessSpelledInSource
 };
 
 /// Kind identifier.
 ///
 /// It can be constructed from any node kind and allows for runtime type
 /// hierarchy checks.
 /// Use getFromNodeKind<T>() to construct them.
 class ASTNodeKind {

clang/include/clang/AST/Expr.h

public:
   /// Returns true if this expression is a bound member function.
   bool isBoundMemberFunction(ASTContext &Ctx) const;
 
   /// Given an expression of bound-member type, find the type
   /// of the member.  Returns null if this is an *overloaded* bound
   /// member expression.
   static QualType findBoundMemberType(const Expr *expr);
 
+  /// Skip past any invisble AST nodes which might surround this
+  /// statement, such as ExprWithCleanups or ImplicitCastExpr nodes,
+  /// but also injected CXXMemberExpr and CXXConstructExpr which represent
+  /// implicit conversions.
+  Expr *IgnoreUnlessSpelledInSource();
+  const Expr *IgnoreUnlessSpelledInSource() const {
+    return const_cast<Expr *>(this)->IgnoreUnlessSpelledInSource();
+  }
+
   /// Skip past any implicit casts which might surround this expression until
   /// reaching a fixed point. Skips:
   /// * ImplicitCastExpr
   /// * FullExpr
   Expr *IgnoreImpCasts() LLVM_READONLY;
   const Expr *IgnoreImpCasts() const {
     return const_cast<Expr *>(this)->IgnoreImpCasts();
   }

clang/lib/AST/ASTContext.cpp

Expr *ASTContext::traverseIgnored(Expr *E) const {
   if (!E)
     return nullptr;
 
   switch (Traversal) {
   case ast_type_traits::TK_AsIs:
     return E;
   case ast_type_traits::TK_IgnoreImplicitCastsAndParentheses:
     return E->IgnoreParenImpCasts();
+  case ast_type_traits::TK_IgnoreUnlessSpelledInSource:
+    return E->IgnoreUnlessSpelledInSource();
   }
   llvm_unreachable("Invalid Traversal type!");
 }
 
 ast_type_traits::DynTypedNode
 ASTContext::traverseIgnored(const ast_type_traits::DynTypedNode &N) const {
   if (const auto *E = N.get<Expr>()) {
     return ast_type_traits::DynTypedNode::create(*traverseIgnored(E));

clang/lib/AST/Expr.cpp

 }
 
 Expr *Expr::IgnoreParenNoopCasts(const ASTContext &Ctx) {
   return IgnoreExprNodes(this, IgnoreParensSingleStep, [&Ctx](Expr *E) {
     return IgnoreNoopCastsSingleStep(Ctx, E);
   });
 }
 
+Expr *Expr::IgnoreUnlessSpelledInSource() {
+  Expr *E = this;
+
+  Expr *LastE = nullptr;
+  while (E != LastE) {
+    LastE = E;
+    E = E->IgnoreImplicit();
+
+    auto SR = E->getSourceRange();
+
+    if (auto *C = dyn_cast<CXXConstructExpr>(E)) {
+      if (C->getNumArgs() == 1) {
+        Expr *A = C->getArg(0);
+        if (A->getSourceRange() == SR || !isa<CXXTemporaryObjectExpr>(C))
+          E = A;
+      }
+    }
+
+    if (auto *C = dyn_cast<CXXMemberCallExpr>(E)) {
+      Expr *ExprNode = C->getImplicitObjectArgument()->IgnoreParenImpCasts();
+      if (ExprNode->getSourceRange() == SR)
+        E = ExprNode;
+    }
+  }
+
+  return E;
+}
+
 bool Expr::isDefaultArgument() const {
   const Expr *E = this;
   if (const MaterializeTemporaryExpr *M = dyn_cast<MaterializeTemporaryExpr>(E))
     E = M->getSubExpr();
 
   while (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
     E = ICE->getSubExprAsWritten();
 

clang/unittests/AST/ASTTraverserTest.cpp

template <typename... NodeType> std::string dumpASTString(NodeType &&... N) {
 
   OS << "\n";
 
   Dumper.Visit(std::forward<NodeType &&>(N)...);
 
   return OS.str();
 }
 
+template <typename... NodeType>
+std::string dumpASTString(ast_type_traits::TraversalKind TK, NodeType &&... N) {
+  std::string Buffer;
+  llvm::raw_string_ostream OS(Buffer);
+
+  TestASTDumper Dumper(OS);
+  Dumper.SetTraversalKind(TK);
+
+  OS << "\n";
+
+  Dumper.Visit(std::forward<NodeType &&>(N)...);
+
+  return OS.str();
+}
+
 const FunctionDecl *getFunctionNode(clang::ASTUnit *AST,
                                     const std::string &Name) {
   auto Result = ast_matchers::match(functionDecl(hasName(Name)).bind("fn"),
                                     AST->getASTContext());
   EXPECT_EQ(Result.size(), 1u);
   return Result[0].getNodeAs<FunctionDecl>("fn");
 }
 
)cpp");
   const auto TL = Parm->getTypeSourceInfo()->getTypeLoc();
   ASSERT_TRUE(TL.getType()->isPointerType());
 
   const auto ATL = TL.getNextTypeLoc().getAs<AttributedTypeLoc>();
   const auto *AS = cast<AddressSpaceAttr>(ATL.getAttr());
   EXPECT_EQ(toTargetAddressSpace(static_cast<LangAS>(AS->getAddressSpace())),
             19u);
 }
+
+TEST(Traverse, IgnoreUnlessSpelledInSource) {
+
+  auto AST = buildASTFromCode(R"cpp(
+
+struct A
+{
+};
+
+struct B
+{
+  B(int);
+  B(A const& a);
+  B();
+};
+
+struct C
+{
+  operator B();
+};
+
+B func1() {
+  return 42;
+}
+
+B func2() {
+  return B{42};
+}
+
+B func3() {
+  return B(42);
+}
+
+B func4() {
+  return B();
+}
+
+B func5() {
+  return B{};
+}
+
+B func6() {
+  return C();
+}
+
+B func7() {
+  return A();
+}
+
+B func8() {
+  return C{};
+}
+
+B func9() {
+  return A{};
+}
+
+B func10() {
+  A a;
+  return a;
+}
+
+B func11() {
+  B b;
+  return b;
+}
+
+B func12() {
+  C c;
+  return c;
+}
+
+)cpp");
+
+  auto getFunctionNode = [&AST](const std::string &name) {
+    auto BN = ast_matchers::match(functionDecl(hasName(name)).bind("fn"),
+                                  AST->getASTContext());
+    EXPECT_EQ(BN.size(), 1u);
+    return BN[0].getNodeAs<Decl>("fn");
+  };
+
+  {
+    auto FN = getFunctionNode("func1");
+
+    EXPECT_EQ(dumpASTString(ast_type_traits::TK_AsIs, FN),
+              R"cpp(
+FunctionDecl 'func1'
+`-CompoundStmt
+  `-ReturnStmt
+    `-ExprWithCleanups
+      `-CXXConstructExpr
+        `-MaterializeTemporaryExpr
+          `-ImplicitCastExpr
+            `-CXXConstructExpr
+              `-IntegerLiteral
+)cpp");
+
+    EXPECT_EQ(
+        dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, FN),
+        R"cpp(
+FunctionDecl 'func1'
+`-CompoundStmt
+  `-ReturnStmt
+    `-IntegerLiteral
+)cpp");
+  }
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func2")),
+            R"cpp(
+FunctionDecl 'func2'
+`-CompoundStmt
+  `-ReturnStmt
+    `-CXXTemporaryObjectExpr
+      `-IntegerLiteral
+)cpp");
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func3")),
+            R"cpp(
+FunctionDecl 'func3'
+`-CompoundStmt
+  `-ReturnStmt
+    `-CXXFunctionalCastExpr
+      `-IntegerLiteral
+)cpp");
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func4")),
+            R"cpp(
+FunctionDecl 'func4'
+`-CompoundStmt
+  `-ReturnStmt
+    `-CXXTemporaryObjectExpr
+)cpp");
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func5")),
+            R"cpp(
+FunctionDecl 'func5'
+`-CompoundStmt
+  `-ReturnStmt
+    `-CXXTemporaryObjectExpr
+)cpp");
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func6")),
+            R"cpp(
+FunctionDecl 'func6'
+`-CompoundStmt
+  `-ReturnStmt
+    `-CXXTemporaryObjectExpr
+)cpp");
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func7")),
+            R"cpp(
+FunctionDecl 'func7'
+`-CompoundStmt
+  `-ReturnStmt
+    `-CXXTemporaryObjectExpr
+)cpp");
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func8")),
+            R"cpp(
+FunctionDecl 'func8'
+`-CompoundStmt
+  `-ReturnStmt
+    `-CXXFunctionalCastExpr
+      `-InitListExpr
+)cpp");
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func9")),
+            R"cpp(
+FunctionDecl 'func9'
+`-CompoundStmt
+  `-ReturnStmt
+    `-CXXFunctionalCastExpr
+      `-InitListExpr
+)cpp");
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func10")),
+            R"cpp(
+FunctionDecl 'func10'
+`-CompoundStmt
+  |-DeclStmt
+  | `-VarDecl 'a'
+  |   `-CXXConstructExpr
+  `-ReturnStmt
+    `-DeclRefExpr 'a'
+)cpp");
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func11")),
+            R"cpp(
+FunctionDecl 'func11'
+`-CompoundStmt
+  |-DeclStmt
+  | `-VarDecl 'b'
+  |   `-CXXConstructExpr
+  `-ReturnStmt
+    `-DeclRefExpr 'b'
+)cpp");
+
+  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                          getFunctionNode("func12")),
+            R"cpp(
+FunctionDecl 'func12'
+`-CompoundStmt
+  |-DeclStmt
+  | `-VarDecl 'c'
+  |   `-CXXConstructExpr
+  `-ReturnStmt
+    `-DeclRefExpr 'c'
+)cpp");
+}
+
 } // namespace clang

clang/unittests/AST/CMakeLists.txt

add_clang_unittest(ASTTests
   ASTContextParentMapTest.cpp
   ASTImporterFixtures.cpp
   ASTImporterTest.cpp
   ASTImporterGenericRedeclTest.cpp
   ASTImporterODRStrategiesTest.cpp
   ASTImporterVisibilityTest.cpp
   ASTTraverserTest.cpp
   ASTTypeTraitsTest.cpp
+  ASTTraverserTest.cpp
   ASTVectorTest.cpp
   CommentLexer.cpp
   CommentParser.cpp
   CommentTextTest.cpp
   DataCollectionTest.cpp
   DeclPrinterTest.cpp
   DeclTest.cpp
   EvaluateAsRValueTest.cpp

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

void foo()
 
   EXPECT_TRUE(matches(
       Code, functionDecl(anyOf(
                 hasDescendant(Matcher),
                 traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses,
                          functionDecl(hasDescendant(Matcher)))))));
 }
 
+TEST(Traversal, traverseUnlessSpelledInSource) {
+
+  StringRef Code = R"cpp(
+
+struct A
+{
+};
+
+struct B
+{
+  B(int);
+  B(A const& a);
+  B();
+};
+
+struct C
+{
+  operator B();
+};
+
+B func1() {
+  return 42;
+}
+
+B func2() {
+  return B{42};
+}
+
+B func3() {
+  return B(42);
+}
+
+B func4() {
+  return B();
+}
+
+B func5() {
+  return B{};
+}
+
+B func6() {
+  return C();
+}
+
+B func7() {
+  return A();
+}
+
+B func8() {
+  return C{};
+}
+
+B func9() {
+  return A{};
+}
+
+B func10() {
+  A a;
+  return a;
+}
+
+B func11() {
+  B b;
+  return b;
+}
+
+B func12() {
+  C c;
+  return c;
+}
+
+)cpp";
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func1"))),
+                                hasReturnValue(integerLiteral(equals(42)))))));
+
+  EXPECT_TRUE(matches(
+      Code,
+      traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+               returnStmt(forFunction(functionDecl(hasName("func2"))),
+                          hasReturnValue(cxxTemporaryObjectExpr(
+                              hasArgument(0, integerLiteral(equals(42)))))))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func3"))),
+                                hasReturnValue(
+                                    cxxFunctionalCastExpr(hasSourceExpression(
+                                        integerLiteral(equals(42)))))))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func4"))),
+                                hasReturnValue(cxxTemporaryObjectExpr())))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func5"))),
+                                hasReturnValue(cxxTemporaryObjectExpr())))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func6"))),
+                                hasReturnValue(cxxTemporaryObjectExpr())))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func7"))),
+                                hasReturnValue(cxxTemporaryObjectExpr())))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func8"))),
+                                hasReturnValue(cxxFunctionalCastExpr(
+                                    hasSourceExpression(initListExpr())))))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func9"))),
+                                hasReturnValue(cxxFunctionalCastExpr(
+                                    hasSourceExpression(initListExpr())))))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func10"))),
+                                hasReturnValue(
+                                    declRefExpr(to(varDecl(hasName("a")))))))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func11"))),
+                                hasReturnValue(
+                                    declRefExpr(to(varDecl(hasName("b")))))))));
+
+  EXPECT_TRUE(matches(
+      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+                     returnStmt(forFunction(functionDecl(hasName("func12"))),
+                                hasReturnValue(
+                                    declRefExpr(to(varDecl(hasName("c")))))))));
+}
+
 TEST(IgnoringImpCasts, MatchesImpCasts) {
   // This test checks that ignoringImpCasts matches when implicit casts are
   // present and its inner matcher alone does not match.
   // Note that this test creates an implicit const cast.
   EXPECT_TRUE(matches("int x = 0; const int y = x;",
                       varDecl(hasInitializer(ignoringImpCasts(
                         declRefExpr(to(varDecl(hasName("x")))))))));
   // This test creates an implict cast from int to char.