[ASTMatcher] Add a node matcher for UnresolvedLookupExpr.

[aaron.ballman]

The changes to docs/tools/dump_ast_matchers.py look to be spurious, can they be reverted?

include/clang/ASTMatchers/ASTMatchers.h

1089 ↗

(On Diff #57590)

s/which can be able to look up/that can be looked up

[alexfh]

In D20360#432874, @aaron.ballman wrote:

The changes to docs/tools/dump_ast_matchers.py look to be spurious, can they be reverted?

The script should be executable, so the change looks fine to me.

[aaron.ballman]

In D20360#432878, @alexfh wrote:

In D20360#432874, @aaron.ballman wrote:

The changes to docs/tools/dump_ast_matchers.py look to be spurious, can they be reverted?

The script should be executable, so the change looks fine to me.

World executable? That's a bit presumptuous. ;-) 0744 may be fine, but 0755 does not seem correct to me.

Regardless, I think that it should be a separate commit, not part of this one as a drive-by (it has security implications, and that deserves review).

[hokein]

Address review comments.

[hokein]

Remove modification of dump_ast_matchers.py

[aaron.ballman]

LGTM!

[hokein]

! In D20360#432882, @aaron.ballman wrote:
World executable? That's a bit presumptuous. ;-) 0744 may be fine, but 0755 does not seem correct to me.

Regardless, I think that it should be a separate commit, not part of this one as a drive-by (it has security implications, and that deserves review).

Has been removed now. Will sent a separate commit for it.

[hokein]

Rebase to master.

[alexfh]

In D20360#432882, @aaron.ballman wrote:

In D20360#432878, @alexfh wrote:

In D20360#432874, @aaron.ballman wrote:

The changes to docs/tools/dump_ast_matchers.py look to be spurious, can they be reverted?

The script should be executable, so the change looks fine to me.

World executable? That's a bit presumptuous. ;-) 0744 may be fine, but 0755 does not seem correct to me.

Regardless, I think that it should be a separate commit, not part of this one as a drive-by (it has security implications, and that deserves review).

Not sure there's any benefit (or any added security) in limiting execution bit to the owner. I've never seen files with 0744 permission mask and when I tried to find some on my machine, I only found a few CUPS binaries. In any case, svn:executable does not allow much customization: http://svnbook.red-bean.com/en/1.7/svn.advanced.props.file-portability.html#svn.advanced.props.special.executable

cfe/trunk/docs/LibASTMatchersReference.html

 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unaryOperator0')"><a name="unaryOperator0Anchor">unaryOperator</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1UnaryOperator.html">UnaryOperator</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="unaryOperator0"><pre>Matches unary operator expressions.
 
 Example matches !a
   !a || b
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('unresolvedLookupExpr0')"><a name="unresolvedLookupExpr0Anchor">unresolvedLookupExpr</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1UnresolvedLookupExpr.html">UnresolvedLookupExpr</a>&gt;...</td></tr>
+<tr><td colspan="4" class="doc" id="unresolvedLookupExpr0"><pre>Matches reference to a name that can be looked up during parsing
+but could not be resolved to a specific declaration.
+
+Given
+  template&lt;typename T&gt;
+  T foo() { T a; return a; }
+  template&lt;typename T&gt;
+  void bar() {
+    foo&lt;T&gt;();
+  }
+unresolvedLookupExpr()
+  matches foo&lt;T&gt;() </pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('userDefinedLiteral0')"><a name="userDefinedLiteral0Anchor">userDefinedLiteral</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1UserDefinedLiteral.html">UserDefinedLiteral</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="userDefinedLiteral0"><pre>Matches user defined literal operator call.
 
 Example match: "foo"_suffix
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('whileStmt0')"><a name="whileStmt0Anchor">whileStmt</a></td><td>Matcher&lt;<a href="http://clang.llvm.org/doxygen/classclang_1_1WhileStmt.html">WhileStmt</a>&gt;...</td></tr>

cfe/trunk/include/clang/ASTMatchers/ASTMatchers.h

 ///   using namespace X;
 /// \endcode
 /// usingDirectiveDecl()
 ///   matches \code using namespace X \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   UsingDirectiveDecl> usingDirectiveDecl;
 
+/// \brief Matches reference to a name that can be looked up during parsing
+/// but could not be resolved to a specific declaration.
+///
+/// Given
+/// \code
+///   template<typename T>
+///   T foo() { T a; return a; }
+///   template<typename T>
+///   void bar() {
+///     foo<T>();
+///   }
+/// \endcode
+/// unresolvedLookupExpr()
+///   matches \code foo<T>() \endcode
+const internal::VariadicDynCastAllOfMatcher<
+   Stmt,
+   UnresolvedLookupExpr> unresolvedLookupExpr;
+
 /// \brief Matches unresolved using value declarations.
 ///
 /// Given
 /// \code
 ///   template<typename X>
 ///   class C : private X {
 ///     using X::x;
 ///   };

cfe/trunk/lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(typedefNameDecl);
   REGISTER_MATCHER(typedefType);
   REGISTER_MATCHER(typeAliasDecl);
   REGISTER_MATCHER(typeLoc);
   REGISTER_MATCHER(unaryExprOrTypeTraitExpr);
   REGISTER_MATCHER(unaryOperator);
   REGISTER_MATCHER(unaryTransformType);
   REGISTER_MATCHER(unless);
+  REGISTER_MATCHER(unresolvedLookupExpr);
   REGISTER_MATCHER(unresolvedUsingTypenameDecl);
   REGISTER_MATCHER(unresolvedUsingValueDecl);
   REGISTER_MATCHER(userDefinedLiteral);
   REGISTER_MATCHER(usingDecl);
   REGISTER_MATCHER(usingDirectiveDecl);
   REGISTER_MATCHER(valueDecl);
   REGISTER_MATCHER(varDecl);
   REGISTER_MATCHER(variableArrayType);

cfe/trunk/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

 
 TEST(EnumConstant, Matches) {
   DeclarationMatcher Matcher = enumConstantDecl(hasName("A"));
   EXPECT_TRUE(matches("enum X{ A };", Matcher));
   EXPECT_TRUE(notMatches("enum X{ B };", Matcher));
   EXPECT_TRUE(notMatches("enum X {};", Matcher));
 }
 
+TEST(Matcher, UnresolvedLookupExpr) {
+  EXPECT_TRUE(matches("template<typename T>"
+                      "T foo() { T a; return a; }"
+                      "template<typename T>"
+                      "void bar() {"
+                      "  foo<T>();"
+                      "}",
+                      unresolvedLookupExpr()));
+}
 
 TEST(Matcher, Call) {
   // FIXME: Do we want to overload Call() to directly take
   // Matcher<Decl>, too?
   StatementMatcher MethodX =
     callExpr(hasDeclaration(cxxMethodDecl(hasName("x"))));
 
   EXPECT_TRUE(matches("class Y { void x() { x(); } };", MethodX));