Adds the AST Matcher library, which provides a in-C++ DSL to express

matches on interesting parts of the AST, and callback mechanisms to
act on them.




git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@159805 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 1979 insertions, 0 deletions

diff --git a/unittests/ASTMatchers/ASTMatchersTest.cpp b/unittests/ASTMatchers/ASTMatchersTest.cpp
new file mode 100644
index 0000000000..290da9005d
--- /dev/null
+++ b/unittests/ASTMatchers/ASTMatchersTest.cpp
@@ -0,0 +1,1979 @@
+//===- unittest/Tooling/ASTMatchersTest.cpp - AST matcher unit tests ------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ASTMatchersTest.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Tooling/Tooling.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace ast_matchers {
+
+TEST(HasNameDeathTest, DiesOnEmptyName) {
+  ASSERT_DEBUG_DEATH({
+    DeclarationMatcher HasEmptyName = record(hasName(""));
+    EXPECT_TRUE(notMatches("class X {};", HasEmptyName));
+  }, "");
+}
+
+TEST(IsDerivedFromDeathTest, DiesOnEmptyBaseName) {
+  ASSERT_DEBUG_DEATH({
+    DeclarationMatcher IsDerivedFromEmpty = record(isDerivedFrom(""));
+    EXPECT_TRUE(notMatches("class X {};", IsDerivedFromEmpty));
+  }, "");
+}
+
+TEST(NameableDeclaration, MatchesVariousDecls) {
+  DeclarationMatcher NamedX = nameableDeclaration(hasName("X"));
+  EXPECT_TRUE(matches("typedef int X;", NamedX));
+  EXPECT_TRUE(matches("int X;", NamedX));
+  EXPECT_TRUE(matches("class foo { virtual void X(); };", NamedX));
+  EXPECT_TRUE(matches("void foo() try { } catch(int X) { }", NamedX));
+  EXPECT_TRUE(matches("void foo() { int X; }", NamedX));
+  EXPECT_TRUE(matches("namespace X { }", NamedX));
+
+  EXPECT_TRUE(notMatches("#define X 1", NamedX));
+}
+
+TEST(DeclarationMatcher, MatchClass) {
+  DeclarationMatcher ClassMatcher(record());
+  EXPECT_FALSE(matches("", ClassMatcher));
+
+  DeclarationMatcher ClassX = record(record(hasName("X")));
+  EXPECT_TRUE(matches("class X;", ClassX));
+  EXPECT_TRUE(matches("class X {};", ClassX));
+  EXPECT_TRUE(matches("template<class T> class X {};", ClassX));
+  EXPECT_TRUE(notMatches("", ClassX));
+}
+
+TEST(DeclarationMatcher, ClassIsDerived) {
+  DeclarationMatcher IsDerivedFromX = record(isDerivedFrom("X"));
+
+  EXPECT_TRUE(matches("class X {}; class Y : public X {};", IsDerivedFromX));
+  EXPECT_TRUE(matches("class X {}; class Y : public X {};", IsDerivedFromX));
+  EXPECT_TRUE(matches("class X {};", IsDerivedFromX));
+  EXPECT_TRUE(matches("class X;", IsDerivedFromX));
+  EXPECT_TRUE(notMatches("class Y;", IsDerivedFromX));
+  EXPECT_TRUE(notMatches("", IsDerivedFromX));
+
+  DeclarationMatcher ZIsDerivedFromX =
+      record(hasName("Z"), isDerivedFrom("X"));
+  EXPECT_TRUE(
+      matches("class X {}; class Y : public X {}; class Z : public Y {};",
+              ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("class X {};"
+              "template<class T> class Y : public X {};"
+              "class Z : public Y<int> {};", ZIsDerivedFromX));
+  EXPECT_TRUE(matches("class X {}; template<class T> class Z : public X {};",
+                      ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("template<class T> class X {}; "
+              "template<class T> class Z : public X<T> {};",
+              ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("template<class T, class U=T> class X {}; "
+              "template<class T> class Z : public X<T> {};",
+              ZIsDerivedFromX));
+  EXPECT_TRUE(
+      notMatches("template<class X> class A { class Z : public X {}; };",
+                 ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("template<class X> class A { public: class Z : public X {}; }; "
+              "class X{}; void y() { A<X>::Z z; }", ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("template <class T> class X {}; "
+              "template<class Y> class A { class Z : public X<Y> {}; };",
+              ZIsDerivedFromX));
+  EXPECT_TRUE(
+      notMatches("template<template<class T> class X> class A { "
+                 "  class Z : public X<int> {}; };", ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("template<template<class T> class X> class A { "
+              "  public: class Z : public X<int> {}; }; "
+              "template<class T> class X {}; void y() { A<X>::Z z; }",
+              ZIsDerivedFromX));
+  EXPECT_TRUE(
+      notMatches("template<class X> class A { class Z : public X::D {}; };",
+                 ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("template<class X> class A { public: "
+              "  class Z : public X::D {}; }; "
+              "class Y { public: class X {}; typedef X D; }; "
+              "void y() { A<Y>::Z z; }", ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("class X {}; typedef X Y; class Z : public Y {};",
+              ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("template<class T> class Y { typedef typename T::U X; "
+              "  class Z : public X {}; };", ZIsDerivedFromX));
+  EXPECT_TRUE(matches("class X {}; class Z : public ::X {};",
+                      ZIsDerivedFromX));
+  EXPECT_TRUE(
+      notMatches("template<class T> class X {}; "
+                "template<class T> class A { class Z : public X<T>::D {}; };",
+                ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("template<class T> class X { public: typedef X<T> D; }; "
+              "template<class T> class A { public: "
+              "  class Z : public X<T>::D {}; }; void y() { A<int>::Z z; }",
+              ZIsDerivedFromX));
+  EXPECT_TRUE(
+      notMatches("template<class X> class A { class Z : public X::D::E {}; };",
+                 ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("class X {}; typedef X V; typedef V W; class Z : public W {};",
+              ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("class X {}; class Y : public X {}; "
+              "typedef Y V; typedef V W; class Z : public W {};",
+              ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("template<class T, class U> class X {}; "
+              "template<class T> class A { class Z : public X<T, int> {}; };",
+              ZIsDerivedFromX));
+  EXPECT_TRUE(
+      notMatches("template<class X> class D { typedef X A; typedef A B; "
+                 "  typedef B C; class Z : public C {}; };",
+                 ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("class X {}; typedef X A; typedef A B; "
+              "class Z : public B {};", ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("class X {}; typedef X A; typedef A B; typedef B C; "
+              "class Z : public C {};", ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("class U {}; typedef U X; typedef X V; "
+              "class Z : public V {};", ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("class Base {}; typedef Base X; "
+              "class Z : public Base {};", ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("class Base {}; typedef Base Base2; typedef Base2 X; "
+              "class Z : public Base {};", ZIsDerivedFromX));
+  EXPECT_TRUE(
+      notMatches("class Base {}; class Base2 {}; typedef Base2 X; "
+                 "class Z : public Base {};", ZIsDerivedFromX));
+  EXPECT_TRUE(
+      matches("class A {}; typedef A X; typedef A Y; "
+              "class Z : public Y {};", ZIsDerivedFromX));
+  EXPECT_TRUE(
+      notMatches("template <typename T> class Z;"
+                 "template <> class Z<void> {};"
+                 "template <typename T> class Z : public Z<void> {};",
+                 IsDerivedFromX));
+  EXPECT_TRUE(
+      matches("template <typename T> class X;"
+              "template <> class X<void> {};"
+              "template <typename T> class X : public X<void> {};",
+              IsDerivedFromX));
+  EXPECT_TRUE(matches(
+      "class X {};"
+      "template <typename T> class Z;"
+      "template <> class Z<void> {};"
+      "template <typename T> class Z : public Z<void>, public X {};",
+      ZIsDerivedFromX));
+
+  // FIXME: Once we have better matchers for template type matching,
+  // get rid of the Variable(...) matching and match the right template
+  // declarations directly.
+  const char *RecursiveTemplateOneParameter =
+      "class Base1 {}; class Base2 {};"
+      "template <typename T> class Z;"
+      "template <> class Z<void> : public Base1 {};"
+      "template <> class Z<int> : public Base2 {};"
+      "template <> class Z<float> : public Z<void> {};"
+      "template <> class Z<double> : public Z<int> {};"
+      "template <typename T> class Z : public Z<float>, public Z<double> {};"
+      "void f() { Z<float> z_float; Z<double> z_double; Z<char> z_char; }";
+  EXPECT_TRUE(matches(
+      RecursiveTemplateOneParameter,
+      variable(hasName("z_float"),
+               hasInitializer(hasType(record(isDerivedFrom("Base1")))))));
+  EXPECT_TRUE(notMatches(
+      RecursiveTemplateOneParameter,
+      variable(
+          hasName("z_float"),
+          hasInitializer(hasType(record(isDerivedFrom("Base2")))))));
+  EXPECT_TRUE(matches(
+      RecursiveTemplateOneParameter,
+      variable(
+          hasName("z_char"),
+          hasInitializer(hasType(record(isDerivedFrom("Base1"),
+                                       isDerivedFrom("Base2")))))));
+
+  const char *RecursiveTemplateTwoParameters =
+      "class Base1 {}; class Base2 {};"
+      "template <typename T1, typename T2> class Z;"
+      "template <typename T> class Z<void, T> : public Base1 {};"
+      "template <typename T> class Z<int, T> : public Base2 {};"
+      "template <typename T> class Z<float, T> : public Z<void, T> {};"
+      "template <typename T> class Z<double, T> : public Z<int, T> {};"
+      "template <typename T1, typename T2> class Z : "
+      "    public Z<float, T2>, public Z<double, T2> {};"
+      "void f() { Z<float, void> z_float; Z<double, void> z_double; "
+      "           Z<char, void> z_char; }";
+  EXPECT_TRUE(matches(
+      RecursiveTemplateTwoParameters,
+      variable(
+          hasName("z_float"),
+          hasInitializer(hasType(record(isDerivedFrom("Base1")))))));
+  EXPECT_TRUE(notMatches(
+      RecursiveTemplateTwoParameters,
+      variable(
+          hasName("z_float"),
+          hasInitializer(hasType(record(isDerivedFrom("Base2")))))));
+  EXPECT_TRUE(matches(
+      RecursiveTemplateTwoParameters,
+      variable(
+          hasName("z_char"),
+          hasInitializer(hasType(record(isDerivedFrom("Base1"),
+                                       isDerivedFrom("Base2")))))));
+}
+
+TEST(DeclarationMatcher, MatchAnyOf) {
+  DeclarationMatcher YOrZDerivedFromX =
+      record(anyOf(hasName("Y"), allOf(isDerivedFrom("X"), hasName("Z"))));
+
+  EXPECT_TRUE(
+      matches("class X {}; class Z : public X {};", YOrZDerivedFromX));
+  EXPECT_TRUE(matches("class Y {};", YOrZDerivedFromX));
+  EXPECT_TRUE(
+      notMatches("class X {}; class W : public X {};", YOrZDerivedFromX));
+  EXPECT_TRUE(notMatches("class Z {};", YOrZDerivedFromX));
+
+  DeclarationMatcher XOrYOrZOrUOrV =
+      record(anyOf(hasName("X"), hasName("Y"), hasName("Z"), hasName("U"),
+                  hasName("V")));
+
+  EXPECT_TRUE(matches("class X {};", XOrYOrZOrUOrV));
+  EXPECT_TRUE(matches("class Y {};", XOrYOrZOrUOrV));
+  EXPECT_TRUE(matches("class Z {};", XOrYOrZOrUOrV));
+  EXPECT_TRUE(matches("class U {};", XOrYOrZOrUOrV));
+  EXPECT_TRUE(matches("class V {};", XOrYOrZOrUOrV));
+  EXPECT_TRUE(notMatches("class A {};", XOrYOrZOrUOrV));
+}
+
+TEST(DeclarationMatcher, MatchHas) {
+  DeclarationMatcher HasClassX = record(has(record(hasName("X"))));
+
+  EXPECT_TRUE(matches("class Y { class X {}; };", HasClassX));
+  EXPECT_TRUE(matches("class X {};", HasClassX));
+
+  DeclarationMatcher YHasClassX =
+      record(hasName("Y"), has(record(hasName("X"))));
+  EXPECT_TRUE(matches("class Y { class X {}; };", YHasClassX));
+  EXPECT_TRUE(notMatches("class X {};", YHasClassX));
+  EXPECT_TRUE(
+      notMatches("class Y { class Z { class X {}; }; };", YHasClassX));
+}
+
+TEST(DeclarationMatcher, MatchHasRecursiveAllOf) {
+  DeclarationMatcher Recursive =
+    record(
+      has(record(
+        has(record(hasName("X"))),
+        has(record(hasName("Y"))),
+        hasName("Z"))),
+      has(record(
+        has(record(hasName("A"))),
+        has(record(hasName("B"))),
+        hasName("C"))),
+      hasName("F"));
+
+  EXPECT_TRUE(matches(
+      "class F {"
+      "  class Z {"
+      "    class X {};"
+      "    class Y {};"
+      "  };"
+      "  class C {"
+      "    class A {};"
+      "    class B {};"
+      "  };"
+      "};", Recursive));
+
+  EXPECT_TRUE(matches(
+      "class F {"
+      "  class Z {"
+      "    class A {};"
+      "    class X {};"
+      "    class Y {};"
+      "  };"
+      "  class C {"
+      "    class X {};"
+      "    class A {};"
+      "    class B {};"
+      "  };"
+      "};", Recursive));
+
+  EXPECT_TRUE(matches(
+      "class O1 {"
+      "  class O2 {"
+      "    class F {"
+      "      class Z {"
+      "        class A {};"
+      "        class X {};"
+      "        class Y {};"
+      "      };"
+      "      class C {"
+      "        class X {};"
+      "        class A {};"
+      "        class B {};"
+      "      };"
+      "    };"
+      "  };"
+      "};", Recursive));
+}
+
+TEST(DeclarationMatcher, MatchHasRecursiveAnyOf) {
+  DeclarationMatcher Recursive =
+      record(
+          anyOf(
+              has(record(
+                  anyOf(
+                      has(record(
+                          hasName("X"))),
+                      has(record(
+                          hasName("Y"))),
+                      hasName("Z")))),
+              has(record(
+                  anyOf(
+                      hasName("C"),
+                      has(record(
+                          hasName("A"))),
+                      has(record(
+                          hasName("B")))))),
+              hasName("F")));
+
+  EXPECT_TRUE(matches("class F {};", Recursive));
+  EXPECT_TRUE(matches("class Z {};", Recursive));
+  EXPECT_TRUE(matches("class C {};", Recursive));
+  EXPECT_TRUE(matches("class M { class N { class X {}; }; };", Recursive));
+  EXPECT_TRUE(matches("class M { class N { class B {}; }; };", Recursive));
+  EXPECT_TRUE(
+      matches("class O1 { class O2 {"
+              "  class M { class N { class B {}; }; }; "
+              "}; };", Recursive));
+}
+
+TEST(DeclarationMatcher, MatchNot) {
+  DeclarationMatcher NotClassX =
+      record(
+          isDerivedFrom("Y"),
+          unless(hasName("Y")),
+          unless(hasName("X")));
+  EXPECT_TRUE(notMatches("", NotClassX));
+  EXPECT_TRUE(notMatches("class Y {};", NotClassX));
+  EXPECT_TRUE(matches("class Y {}; class Z : public Y {};", NotClassX));
+  EXPECT_TRUE(notMatches("class Y {}; class X : public Y {};", NotClassX));
+  EXPECT_TRUE(
+      notMatches("class Y {}; class Z {}; class X : public Y {};",
+                 NotClassX));
+
+  DeclarationMatcher ClassXHasNotClassY =
+      record(
+          hasName("X"),
+          has(record(hasName("Z"))),
+          unless(
+              has(record(hasName("Y")))));
+  EXPECT_TRUE(matches("class X { class Z {}; };", ClassXHasNotClassY));
+  EXPECT_TRUE(notMatches("class X { class Y {}; class Z {}; };",
+                         ClassXHasNotClassY));
+}
+
+TEST(DeclarationMatcher, HasDescendant) {
+  DeclarationMatcher ZDescendantClassX =
+      record(
+          hasDescendant(record(hasName("X"))),
+          hasName("Z"));
+  EXPECT_TRUE(matches("class Z { class X {}; };", ZDescendantClassX));
+  EXPECT_TRUE(
+      matches("class Z { class Y { class X {}; }; };", ZDescendantClassX));
+  EXPECT_TRUE(
+      matches("class Z { class A { class Y { class X {}; }; }; };",
+              ZDescendantClassX));
+  EXPECT_TRUE(
+      matches("class Z { class A { class B { class Y { class X {}; }; }; }; };",
+              ZDescendantClassX));
+  EXPECT_TRUE(notMatches("class Z {};", ZDescendantClassX));
+
+  DeclarationMatcher ZDescendantClassXHasClassY =
+      record(
+          hasDescendant(record(has(record(hasName("Y"))),
+                              hasName("X"))),
+          hasName("Z"));
+  EXPECT_TRUE(matches("class Z { class X { class Y {}; }; };",
+              ZDescendantClassXHasClassY));
+  EXPECT_TRUE(
+      matches("class Z { class A { class B { class X { class Y {}; }; }; }; };",
+              ZDescendantClassXHasClassY));
+  EXPECT_TRUE(notMatches(
+      "class Z {"
+      "  class A {"
+      "    class B {"
+      "      class X {"
+      "        class C {"
+      "          class Y {};"
+      "        };"
+      "      };"
+      "    }; "
+      "  };"
+      "};", ZDescendantClassXHasClassY));
+
+  DeclarationMatcher ZDescendantClassXDescendantClassY =
+      record(
+          hasDescendant(record(hasDescendant(record(hasName("Y"))),
+                              hasName("X"))),
+          hasName("Z"));
+  EXPECT_TRUE(
+      matches("class Z { class A { class X { class B { class Y {}; }; }; }; };",
+              ZDescendantClassXDescendantClassY));
+  EXPECT_TRUE(matches(
+      "class Z {"
+      "  class A {"
+      "    class X {"
+      "      class B {"
+      "        class Y {};"
+      "      };"
+      "      class Y {};"
+      "    };"
+      "  };"
+      "};", ZDescendantClassXDescendantClassY));
+}
+
+TEST(StatementMatcher, Has) {
+  StatementMatcher HasVariableI =
+      expression(
+          hasType(pointsTo(record(hasName("X")))),
+          has(declarationReference(to(variable(hasName("i"))))));
+
+  EXPECT_TRUE(matches(
+      "class X; X *x(int); void c() { int i; x(i); }", HasVariableI));
+  EXPECT_TRUE(notMatches(
+      "class X; X *x(int); void c() { int i; x(42); }", HasVariableI));
+}
+
+TEST(StatementMatcher, HasDescendant) {
+  StatementMatcher HasDescendantVariableI =
+      expression(
+          hasType(pointsTo(record(hasName("X")))),
+          hasDescendant(declarationReference(to(variable(hasName("i"))))));
+
+  EXPECT_TRUE(matches(
+      "class X; X *x(bool); bool b(int); void c() { int i; x(b(i)); }",
+      HasDescendantVariableI));
+  EXPECT_TRUE(notMatches(
+      "class X; X *x(bool); bool b(int); void c() { int i; x(b(42)); }",
+      HasDescendantVariableI));
+}
+
+TEST(TypeMatcher, MatchesClassType) {
+  TypeMatcher TypeA = hasDeclaration(record(hasName("A")));
+
+  EXPECT_TRUE(matches("class A { public: A *a; };", TypeA));
+  EXPECT_TRUE(notMatches("class A {};", TypeA));
+
+  TypeMatcher TypeDerivedFromA = hasDeclaration(record(isDerivedFrom("A")));
+
+  EXPECT_TRUE(matches("class A {}; class B : public A { public: B *b; };",
+              TypeDerivedFromA));
+  EXPECT_TRUE(notMatches("class A {};", TypeA));
+
+  TypeMatcher TypeAHasClassB = hasDeclaration(
+      record(hasName("A"), has(record(hasName("B")))));
+
+  EXPECT_TRUE(
+      matches("class A { public: A *a; class B {}; };", TypeAHasClassB));
+}
+
+// Returns from Run whether 'bound_nodes' contain a Decl bound to 'Id', which
+// can be dynamically casted to T.
+// Optionally checks that the check succeeded a specific number of times.
+template <typename T>
+class VerifyIdIsBoundToDecl : public BoundNodesCallback {
+public:
+  // Create an object that checks that a node of type 'T' was bound to 'Id'.
+  // Does not check for a certain number of matches.
+  explicit VerifyIdIsBoundToDecl(const std::string& Id)
+    : Id(Id), ExpectedCount(-1), Count(0) {}
+
+  // Create an object that checks that a node of type 'T' was bound to 'Id'.
+  // Checks that there were exactly 'ExpectedCount' matches.
+  explicit VerifyIdIsBoundToDecl(const std::string& Id, int ExpectedCount)
+    : Id(Id), ExpectedCount(ExpectedCount), Count(0) {}
+
+  ~VerifyIdIsBoundToDecl() {
+    if (ExpectedCount != -1) {
+      EXPECT_EQ(ExpectedCount, Count);
+    }
+  }
+
+  virtual bool run(const BoundNodes *Nodes) {
+    if (Nodes->getDeclAs<T>(Id) != NULL) {
+      ++Count;
+      return true;
+    }
+    return false;
+  }
+
+private:
+  const std::string Id;
+  const int ExpectedCount;
+  int Count;
+};
+template <typename T>
+class VerifyIdIsBoundToStmt : public BoundNodesCallback {
+public:
+  explicit VerifyIdIsBoundToStmt(const std::string &Id) : Id(Id) {}
+  virtual bool run(const BoundNodes *Nodes) {
+    const T *Node = Nodes->getStmtAs<T>(Id);
+    return Node != NULL;
+  }
+private:
+  const std::string Id;
+};
+
+TEST(Matcher, BindMatchedNodes) {
+  DeclarationMatcher ClassX = has(id("x", record(hasName("X"))));
+
+  EXPECT_TRUE(matchAndVerifyResultTrue("class X {};",
+      ClassX, new VerifyIdIsBoundToDecl<clang::CXXRecordDecl>("x")));
+
+  EXPECT_TRUE(matchAndVerifyResultFalse("class X {};",
+      ClassX, new VerifyIdIsBoundToDecl<clang::CXXRecordDecl>("other-id")));
+
+  TypeMatcher TypeAHasClassB = hasDeclaration(
+      record(hasName("A"), has(id("b", record(hasName("B"))))));
+
+  EXPECT_TRUE(matchAndVerifyResultTrue("class A { public: A *a; class B {}; };",
+      TypeAHasClassB,
+      new VerifyIdIsBoundToDecl<clang::Decl>("b")));
+
+  StatementMatcher MethodX = id("x", call(callee(method(hasName("x")))));
+
+  EXPECT_TRUE(matchAndVerifyResultTrue("class A { void x() { x(); } };",
+      MethodX,
+      new VerifyIdIsBoundToStmt<clang::CXXMemberCallExpr>("x")));
+}
+
+TEST(HasType, TakesQualTypeMatcherAndMatchesExpr) {
+  TypeMatcher ClassX = hasDeclaration(record(hasName("X")));
+  EXPECT_TRUE(
+      matches("class X {}; void y(X &x) { x; }", expression(hasType(ClassX))));
+  EXPECT_TRUE(
+      notMatches("class X {}; void y(X *x) { x; }",
+                 expression(hasType(ClassX))));
+  EXPECT_TRUE(
+      matches("class X {}; void y(X *x) { x; }",
+              expression(hasType(pointsTo(ClassX)))));
+}
+
+TEST(HasType, TakesQualTypeMatcherAndMatchesValueDecl) {
+  TypeMatcher ClassX = hasDeclaration(record(hasName("X")));
+  EXPECT_TRUE(
+      matches("class X {}; void y() { X x; }", variable(hasType(ClassX))));
+  EXPECT_TRUE(
+      notMatches("class X {}; void y() { X *x; }", variable(hasType(ClassX))));
+  EXPECT_TRUE(
+      matches("class X {}; void y() { X *x; }",
+              variable(hasType(pointsTo(ClassX)))));
+}
+
+TEST(HasType, TakesDeclMatcherAndMatchesExpr) {
+  DeclarationMatcher ClassX = record(hasName("X"));
+  EXPECT_TRUE(
+      matches("class X {}; void y(X &x) { x; }", expression(hasType(ClassX))));
+  EXPECT_TRUE(
+      notMatches("class X {}; void y(X *x) { x; }",
+                 expression(hasType(ClassX))));
+}
+
+TEST(HasType, TakesDeclMatcherAndMatchesValueDecl) {
+  DeclarationMatcher ClassX = record(hasName("X"));
+  EXPECT_TRUE(
+      matches("class X {}; void y() { X x; }", variable(hasType(ClassX))));
+  EXPECT_TRUE(
+      notMatches("class X {}; void y() { X *x; }", variable(hasType(ClassX))));
+}
+
+TEST(Matcher, Call) {
+  // FIXME: Do we want to overload Call() to directly take
+  // Matcher<clang::Decl>, too?
+  StatementMatcher MethodX = call(hasDeclaration(method(hasName("x"))));
+
+  EXPECT_TRUE(matches("class Y { void x() { x(); } };", MethodX));
+  EXPECT_TRUE(notMatches("class Y { void x() {} };", MethodX));
+
+  StatementMatcher MethodOnY = call(on(hasType(record(hasName("Y")))));
+
+  EXPECT_TRUE(
+      matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
+              MethodOnY));
+  EXPECT_TRUE(
+      matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
+              MethodOnY));
+  EXPECT_TRUE(
+      notMatches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
+                 MethodOnY));
+  EXPECT_TRUE(
+      notMatches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
+                 MethodOnY));
+  EXPECT_TRUE(
+      notMatches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
+                 MethodOnY));
+
+  StatementMatcher MethodOnYPointer =
+      call(on(hasType(pointsTo(record(hasName("Y"))))));
+
+  EXPECT_TRUE(
+      matches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
+              MethodOnYPointer));
+  EXPECT_TRUE(
+      matches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
+              MethodOnYPointer));
+  EXPECT_TRUE(
+      matches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
+              MethodOnYPointer));
+  EXPECT_TRUE(
+      notMatches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
+                 MethodOnYPointer));
+  EXPECT_TRUE(
+      notMatches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
+                 MethodOnYPointer));
+}
+
+TEST(Matcher, OverloadedOperatorCall) {
+  StatementMatcher OpCall = overloadedOperatorCall();
+  // Unary operator
+  EXPECT_TRUE(matches("class Y { }; "
+              "bool operator!(Y x) { return false; }; "
+              "Y y; bool c = !y;", OpCall));
+  // No match -- special operators like "new", "delete"
+  // FIXME: operator new takes size_t, for which we need stddef.h, for which
+  // we need to figure out include paths in the test.
+  // EXPECT_TRUE(NotMatches("#include <stddef.h>\n"
+  //             "class Y { }; "
+  //             "void *operator new(size_t size) { return 0; } "
+  //             "Y *y = new Y;", OpCall));
+  EXPECT_TRUE(notMatches("class Y { }; "
+              "void operator delete(void *p) { } "
+              "void a() {Y *y = new Y; delete y;}", OpCall));
+  // Binary operator
+  EXPECT_TRUE(matches("class Y { }; "
+              "bool operator&&(Y x, Y y) { return true; }; "
+              "Y a; Y b; bool c = a && b;",
+              OpCall));
+  // No match -- normal operator, not an overloaded one.
+  EXPECT_TRUE(notMatches("bool x = true, y = true; bool t = x && y;", OpCall));
+  EXPECT_TRUE(notMatches("int t = 5 << 2;", OpCall));
+}
+
+TEST(Matcher, HasOperatorNameForOverloadedOperatorCall) {
+  StatementMatcher OpCallAndAnd =
+      overloadedOperatorCall(hasOverloadedOperatorName("&&"));
+  EXPECT_TRUE(matches("class Y { }; "
+              "bool operator&&(Y x, Y y) { return true; }; "
+              "Y a; Y b; bool c = a && b;", OpCallAndAnd));
+  StatementMatcher OpCallLessLess =
+      overloadedOperatorCall(hasOverloadedOperatorName("<<"));
+  EXPECT_TRUE(notMatches("class Y { }; "
+              "bool operator&&(Y x, Y y) { return true; }; "
+              "Y a; Y b; bool c = a && b;",
+              OpCallLessLess));
+}
+
+TEST(Matcher, ThisPointerType) {
+  StatementMatcher MethodOnY = call(thisPointerType(record(hasName("Y"))));
+
+  EXPECT_TRUE(
+      matches("class Y { public: void x(); }; void z() { Y y; y.x(); }",
+              MethodOnY));
+  EXPECT_TRUE(
+      matches("class Y { public: void x(); }; void z(Y &y) { y.x(); }",
+              MethodOnY));
+  EXPECT_TRUE(
+      matches("class Y { public: void x(); }; void z(Y *&y) { y->x(); }",
+              MethodOnY));
+  EXPECT_TRUE(
+      matches("class Y { public: void x(); }; void z(Y y[]) { y->x(); }",
+              MethodOnY));
+  EXPECT_TRUE(
+      matches("class Y { public: void x(); }; void z() { Y *y; y->x(); }",
+              MethodOnY));
+
+  EXPECT_TRUE(matches(
+      "class Y {"
+      "  public: virtual void x();"
+      "};"
+      "class X : public Y {"
+      "  public: virtual void x();"
+      "};"
+      "void z() { X *x; x->Y::x(); }", MethodOnY));
+}
+
+TEST(Matcher, VariableUsage) {
+  StatementMatcher Reference =
+      declarationReference(to(
+          variable(hasInitializer(
+              call(thisPointerType(record(hasName("Y"))))))));
+
+  EXPECT_TRUE(matches(
+      "class Y {"
+      " public:"
+      "  bool x() const;"
+      "};"
+      "void z(const Y &y) {"
+      "  bool b = y.x();"
+      "  if (b) {}"
+      "}", Reference));
+
+  EXPECT_TRUE(notMatches(
+      "class Y {"
+      " public:"
+      "  bool x() const;"
+      "};"
+      "void z(const Y &y) {"
+      "  bool b = y.x();"
+      "}", Reference));
+}
+
+TEST(Matcher, CalledVariable) {
+  StatementMatcher CallOnVariableY = expression(
+      call(on(declarationReference(to(variable(hasName("y")))))));
+
+  EXPECT_TRUE(matches(
+      "class Y { public: void x() { Y y; y.x(); } };", CallOnVariableY));
+  EXPECT_TRUE(matches(
+      "class Y { public: void x() const { Y y; y.x(); } };", CallOnVariableY));
+  EXPECT_TRUE(matches(
+      "class Y { public: void x(); };"
+      "class X : public Y { void z() { X y; y.x(); } };", CallOnVariableY));
+  EXPECT_TRUE(matches(
+      "class Y { public: void x(); };"
+      "class X : public Y { void z() { X *y; y->x(); } };", CallOnVariableY));
+  EXPECT_TRUE(notMatches(
+      "class Y { public: void x(); };"
+      "class X : public Y { void z() { unsigned long y; ((X*)y)->x(); } };",
+      CallOnVariableY));
+}
+
+TEST(MemberExpression, DoesNotMatchClasses) {
+  EXPECT_TRUE(notMatches("class Y { void x() {} };", memberExpression()));
+}
+
+TEST(MemberExpression, MatchesMemberFunctionCall) {
+  EXPECT_TRUE(matches("class Y { void x() { x(); } };", memberExpression()));
+}
+
+TEST(MemberExpression, MatchesVariable) {
+  EXPECT_TRUE(
+      matches("class Y { void x() { this->y; } int y; };", memberExpression()));
+  EXPECT_TRUE(
+      matches("class Y { void x() { y; } int y; };", memberExpression()));
+  EXPECT_TRUE(
+      matches("class Y { void x() { Y y; y.y; } int y; };",
+              memberExpression()));
+}
+
+TEST(MemberExpression, MatchesStaticVariable) {
+  EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
+              memberExpression()));
+  EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
+              memberExpression()));
+  EXPECT_TRUE(notMatches("class Y { void x() { Y::y; } static int y; };",
+              memberExpression()));
+}
+
+TEST(IsArrow, MatchesMemberVariablesViaArrow) {
+  EXPECT_TRUE(matches("class Y { void x() { this->y; } int y; };",
+              memberExpression(isArrow())));
+  EXPECT_TRUE(matches("class Y { void x() { y; } int y; };",
+              memberExpression(isArrow())));
+  EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } int y; };",
+              memberExpression(isArrow())));
+}
+
+TEST(IsArrow, MatchesStaticMemberVariablesViaArrow) {
+  EXPECT_TRUE(matches("class Y { void x() { this->y; } static int y; };",
+              memberExpression(isArrow())));
+  EXPECT_TRUE(notMatches("class Y { void x() { y; } static int y; };",
+              memberExpression(isArrow())));
+  EXPECT_TRUE(notMatches("class Y { void x() { (*this).y; } static int y; };",
+              memberExpression(isArrow())));
+}
+
+TEST(IsArrow, MatchesMemberCallsViaArrow) {
+  EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
+              memberExpression(isArrow())));
+  EXPECT_TRUE(matches("class Y { void x() { x(); } };",
+              memberExpression(isArrow())));
+  EXPECT_TRUE(notMatches("class Y { void x() { Y y; y.x(); } };",
+              memberExpression(isArrow())));
+}
+
+TEST(Callee, MatchesDeclarations) {
+  StatementMatcher CallMethodX = call(callee(method(hasName("x"))));
+
+  EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX));
+  EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX));
+}
+
+TEST(Callee, MatchesMemberExpressions) {
+  EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
+              call(callee(memberExpression()))));
+  EXPECT_TRUE(
+      notMatches("class Y { void x() { this->x(); } };", call(callee(call()))));
+}
+
+TEST(Function, MatchesFunctionDeclarations) {
+  StatementMatcher CallFunctionF = call(callee(function(hasName("f"))));
+
+  EXPECT_TRUE(matches("void f() { f(); }", CallFunctionF));
+  EXPECT_TRUE(notMatches("void f() { }", CallFunctionF));
+
+  // Dependent contexts, but a non-dependent call.
+  EXPECT_TRUE(matches("void f(); template <int N> void g() { f(); }",
+                      CallFunctionF));
+  EXPECT_TRUE(
+      matches("void f(); template <int N> struct S { void g() { f(); } };",
+              CallFunctionF));
+
+  // Depedent calls don't match.
+  EXPECT_TRUE(
+      notMatches("void f(int); template <typename T> void g(T t) { f(t); }",
+                 CallFunctionF));
+  EXPECT_TRUE(
+      notMatches("void f(int);"
+                 "template <typename T> struct S { void g(T t) { f(t); } };",
+                 CallFunctionF));
+}
+
+TEST(Matcher, Argument) {
+  StatementMatcher CallArgumentY = expression(call(
+      hasArgument(0, declarationReference(to(variable(hasName("y")))))));
+
+  EXPECT_TRUE(matches("void x(int) { int y; x(y); }", CallArgumentY));
+  EXPECT_TRUE(
+      matches("class X { void x(int) { int y; x(y); } };", CallArgumentY));
+  EXPECT_TRUE(notMatches("void x(int) { int z; x(z); }", CallArgumentY));
+
+  StatementMatcher WrongIndex = expression(call(
+      hasArgument(42, declarationReference(to(variable(hasName("y")))))));
+  EXPECT_TRUE(notMatches("void x(int) { int y; x(y); }", WrongIndex));
+}
+
+TEST(Matcher, AnyArgument) {
+  StatementMatcher CallArgumentY = expression(call(
+      hasAnyArgument(declarationReference(to(variable(hasName("y")))))));
+  EXPECT_TRUE(matches("void x(int, int) { int y; x(1, y); }", CallArgumentY));
+  EXPECT_TRUE(matches("void x(int, int) { int y; x(y, 42); }", CallArgumentY));
+  EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY));
+}
+
+TEST(Matcher, ArgumentCount) {
+  StatementMatcher Call1Arg = expression(call(argumentCountIs(1)));
+
+  EXPECT_TRUE(matches("void x(int) { x(0); }", Call1Arg));
+  EXPECT_TRUE(matches("class X { void x(int) { x(0); } };", Call1Arg));
+  EXPECT_TRUE(notMatches("void x(int, int) { x(0, 0); }", Call1Arg));
+}
+
+TEST(Matcher, References) {
+  DeclarationMatcher ReferenceClassX = variable(
+      hasType(references(record(hasName("X")))));
+  EXPECT_TRUE(matches("class X {}; void y(X y) { X &x = y; }",
+                      ReferenceClassX));
+  EXPECT_TRUE(
+      matches("class X {}; void y(X y) { const X &x = y; }", ReferenceClassX));
+  EXPECT_TRUE(
+      notMatches("class X {}; void y(X y) { X x = y; }", ReferenceClassX));
+  EXPECT_TRUE(
+      notMatches("class X {}; void y(X *y) { X *&x = y; }", ReferenceClassX));
+}
+
+TEST(HasParameter, CallsInnerMatcher) {
+  EXPECT_TRUE(matches("class X { void x(int) {} };",
+      method(hasParameter(0, variable()))));
+  EXPECT_TRUE(notMatches("class X { void x(int) {} };",
+      method(hasParameter(0, hasName("x")))));
+}
+
+TEST(HasParameter, DoesNotMatchIfIndexOutOfBounds) {
+  EXPECT_TRUE(notMatches("class X { void x(int) {} };",
+      method(hasParameter(42, variable()))));
+}
+
+TEST(HasType, MatchesParameterVariableTypesStrictly) {
+  EXPECT_TRUE(matches("class X { void x(X x) {} };",
+      method(hasParameter(0, hasType(record(hasName("X")))))));
+  EXPECT_TRUE(notMatches("class X { void x(const X &x) {} };",
+      method(hasParameter(0, hasType(record(hasName("X")))))));
+  EXPECT_TRUE(matches("class X { void x(const X *x) {} };",
+      method(hasParameter(0, hasType(pointsTo(record(hasName("X"))))))));
+  EXPECT_TRUE(matches("class X { void x(const X &x) {} };",
+      method(hasParameter(0, hasType(references(record(hasName("X"))))))));
+}
+
+TEST(HasAnyParameter, MatchesIndependentlyOfPosition) {
+  EXPECT_TRUE(matches("class Y {}; class X { void x(X x, Y y) {} };",
+      method(hasAnyParameter(hasType(record(hasName("X")))))));
+  EXPECT_TRUE(matches("class Y {}; class X { void x(Y y, X x) {} };",
+      method(hasAnyParameter(hasType(record(hasName("X")))))));
+}
+
+TEST(HasAnyParameter, DoesntMatchIfInnerMatcherDoesntMatch) {
+  EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
+      method(hasAnyParameter(hasType(record(hasName("X")))))));
+}
+
+TEST(HasAnyParameter, DoesNotMatchThisPointer) {
+  EXPECT_TRUE(notMatches("class Y {}; class X { void x() {} };",
+      method(hasAnyParameter(hasType(pointsTo(record(hasName("X"))))))));
+}
+
+TEST(HasName, MatchesParameterVariableDeclartions) {
+  EXPECT_TRUE(matches("class Y {}; class X { void x(int x) {} };",
+      method(hasAnyParameter(hasName("x")))));
+  EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
+      method(hasAnyParameter(hasName("x")))));