//= unittests/ASTMatchers/ASTMatchersTraversalTest.cpp - matchers unit tests =//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "ASTMatchersTest.h"
#include "clang/AST/Attrs.inc"
#include "clang/AST/PrettyPrinter.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Support/Host.h"
#include "gtest/gtest.h"

namespace clang {
namespace ast_matchers {

TEST(DeclarationMatcher, hasMethod) {
  EXPECT_TRUE(matches("class A { void func(); };",
                      cxxRecordDecl(hasMethod(hasName("func")))));
  EXPECT_TRUE(notMatches("class A { void func(); };",
                         cxxRecordDecl(hasMethod(isPublic()))));
}

TEST(DeclarationMatcher, ClassDerivedFromDependentTemplateSpecialization) {
  EXPECT_TRUE(matches(
    "template <typename T> struct A {"
      "  template <typename T2> struct F {};"
      "};"
      "template <typename T> struct B : A<T>::template F<T> {};"
      "B<int> b;",
    cxxRecordDecl(hasName("B"), isDerivedFrom(recordDecl()))));
}

TEST(DeclarationMatcher, hasDeclContext) {
  EXPECT_TRUE(matches(
    "namespace N {"
      "  namespace M {"
      "    class D {};"
      "  }"
      "}",
    recordDecl(hasDeclContext(namespaceDecl(hasName("M"))))));
  EXPECT_TRUE(notMatches(
    "namespace N {"
      "  namespace M {"
      "    class D {};"
      "  }"
      "}",
    recordDecl(hasDeclContext(namespaceDecl(hasName("N"))))));

  EXPECT_TRUE(matches("namespace {"
                        "  namespace M {"
                        "    class D {};"
                        "  }"
                        "}",
                      recordDecl(hasDeclContext(namespaceDecl(
                        hasName("M"), hasDeclContext(namespaceDecl()))))));

  EXPECT_TRUE(matches("class D{};", decl(hasDeclContext(decl()))));
}

TEST(HasDescendant, MatchesDescendantTypes) {
  EXPECT_TRUE(matches("void f() { int i = 3; }",
                      decl(hasDescendant(loc(builtinType())))));
  EXPECT_TRUE(matches("void f() { int i = 3; }",
                      stmt(hasDescendant(builtinType()))));

  EXPECT_TRUE(matches("void f() { int i = 3; }",
                      stmt(hasDescendant(loc(builtinType())))));
  EXPECT_TRUE(matches("void f() { int i = 3; }",
                      stmt(hasDescendant(qualType(builtinType())))));

  EXPECT_TRUE(notMatches("void f() { float f = 2.0f; }",
                         stmt(hasDescendant(isInteger()))));

  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void f() { int a; float c; int d; int e; }",
    functionDecl(forEachDescendant(
      varDecl(hasDescendant(isInteger())).bind("x"))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 3)));
}

TEST(HasDescendant, MatchesDescendantsOfTypes) {
  EXPECT_TRUE(matches("void f() { int*** i; }",
                      qualType(hasDescendant(builtinType()))));
  EXPECT_TRUE(matches("void f() { int*** i; }",
                      qualType(hasDescendant(
                        pointerType(pointee(builtinType()))))));
  EXPECT_TRUE(matches("void f() { int*** i; }",
                      typeLoc(hasDescendant(loc(builtinType())))));

  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void f() { int*** i; }",
    qualType(asString("int ***"), forEachDescendant(pointerType().bind("x"))),
    std::make_unique<VerifyIdIsBoundTo<Type>>("x", 2)));
}


TEST(Has, MatchesChildrenOfTypes) {
  EXPECT_TRUE(matches("int i;",
                      varDecl(hasName("i"), has(isInteger()))));
  EXPECT_TRUE(notMatches("int** i;",
                         varDecl(hasName("i"), has(isInteger()))));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "int (*f)(float, int);",
    qualType(functionType(), forEach(qualType(isInteger()).bind("x"))),
    std::make_unique<VerifyIdIsBoundTo<QualType>>("x", 2)));
}

TEST(Has, MatchesChildTypes) {
  EXPECT_TRUE(matches(
    "int* i;",
    varDecl(hasName("i"), hasType(qualType(has(builtinType()))))));
  EXPECT_TRUE(notMatches(
    "int* i;",
    varDecl(hasName("i"), hasType(qualType(has(pointerType()))))));
}

TEST(StatementMatcher, Has) {
  StatementMatcher HasVariableI =
      expr(hasType(pointsTo(recordDecl(hasName("X")))),
           has(ignoringParenImpCasts(declRefExpr(to(varDecl(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 =
    expr(hasType(pointsTo(recordDecl(hasName("X")))),
         hasDescendant(declRefExpr(to(varDecl(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(recordDecl(hasName("A")));

  EXPECT_TRUE(matches("class A { public: A *a; };", TypeA));
  EXPECT_TRUE(notMatches("class A {};", TypeA));

  TypeMatcher TypeDerivedFromA =
    hasDeclaration(cxxRecordDecl(isDerivedFrom("A")));

  EXPECT_TRUE(matches("class A {}; class B : public A { public: B *b; };",
                      TypeDerivedFromA));
  EXPECT_TRUE(notMatches("class A {};", TypeA));

  TypeMatcher TypeAHasClassB = hasDeclaration(
    recordDecl(hasName("A"), has(recordDecl(hasName("B")))));

  EXPECT_TRUE(
    matches("class A { public: A *a; class B {}; };", TypeAHasClassB));

  EXPECT_TRUE(matchesC("struct S {}; void f(void) { struct S s; }",
                       varDecl(hasType(namedDecl(hasName("S"))))));
}

TEST(TypeMatcher, MatchesDeclTypes) {
  // TypedefType -> TypedefNameDecl
  EXPECT_TRUE(matches("typedef int I; void f(I i);",
                      parmVarDecl(hasType(namedDecl(hasName("I"))))));
  // ObjCObjectPointerType
  EXPECT_TRUE(matchesObjC("@interface Foo @end void f(Foo *f);",
                          parmVarDecl(hasType(objcObjectPointerType()))));
  // ObjCObjectPointerType -> ObjCInterfaceType -> ObjCInterfaceDecl
  EXPECT_TRUE(matchesObjC(
    "@interface Foo @end void f(Foo *f);",
    parmVarDecl(hasType(pointsTo(objcInterfaceDecl(hasName("Foo")))))));
  // TemplateTypeParmType
  EXPECT_TRUE(matches("template <typename T> void f(T t);",
                      parmVarDecl(hasType(templateTypeParmType()))));
  // TemplateTypeParmType -> TemplateTypeParmDecl
  EXPECT_TRUE(matches("template <typename T> void f(T t);",
                      parmVarDecl(hasType(namedDecl(hasName("T"))))));
  // InjectedClassNameType
  EXPECT_TRUE(matches("template <typename T> struct S {"
                        "  void f(S s);"
                        "};",
                      parmVarDecl(hasType(injectedClassNameType()))));
  EXPECT_TRUE(notMatches("template <typename T> struct S {"
                           "  void g(S<T> s);"
                           "};",
                         parmVarDecl(hasType(injectedClassNameType()))));
  // InjectedClassNameType -> CXXRecordDecl
  EXPECT_TRUE(matches("template <typename T> struct S {"
                        "  void f(S s);"
                        "};",
                      parmVarDecl(hasType(namedDecl(hasName("S"))))));

  static const char Using[] = "template <typename T>"
    "struct Base {"
    "  typedef T Foo;"
    "};"
    ""
    "template <typename T>"
    "struct S : private Base<T> {"
    "  using typename Base<T>::Foo;"
    "  void f(Foo);"
    "};";
  // UnresolvedUsingTypenameDecl
  EXPECT_TRUE(matches(Using, unresolvedUsingTypenameDecl(hasName("Foo"))));
  // UnresolvedUsingTypenameType -> UnresolvedUsingTypenameDecl
  EXPECT_TRUE(matches(Using, parmVarDecl(hasType(namedDecl(hasName("Foo"))))));
}

TEST(HasDeclaration, HasDeclarationOfEnumType) {
  EXPECT_TRUE(matches("enum X {}; void y(X *x) { x; }",
                      expr(hasType(pointsTo(
                        qualType(hasDeclaration(enumDecl(hasName("X")))))))));
}

TEST(HasDeclaration, HasGetDeclTraitTest) {
  static_assert(internal::has_getDecl<TypedefType>::value,
                "Expected TypedefType to have a getDecl.");
  static_assert(internal::has_getDecl<RecordType>::value,
                "Expected RecordType to have a getDecl.");
  static_assert(!internal::has_getDecl<TemplateSpecializationType>::value,
                "Expected TemplateSpecializationType to *not* have a getDecl.");
}

TEST(HasDeclaration, ElaboratedType) {
  EXPECT_TRUE(matches(
      "namespace n { template <typename T> struct X {}; }"
      "void f(n::X<int>);",
      parmVarDecl(hasType(qualType(hasDeclaration(cxxRecordDecl()))))));
  EXPECT_TRUE(matches(
      "namespace n { template <typename T> struct X {}; }"
      "void f(n::X<int>);",
      parmVarDecl(hasType(elaboratedType(hasDeclaration(cxxRecordDecl()))))));
}

TEST(HasDeclaration, HasDeclarationOfTypeWithDecl) {
  EXPECT_TRUE(matches("typedef int X; X a;",
                      varDecl(hasName("a"),
                              hasType(typedefType(hasDeclaration(decl()))))));

  // FIXME: Add tests for other types with getDecl() (e.g. RecordType)
}

TEST(HasDeclaration, HasDeclarationOfTemplateSpecializationType) {
  EXPECT_TRUE(matches("template <typename T> class A {}; A<int> a;",
                      varDecl(hasType(templateSpecializationType(
                        hasDeclaration(namedDecl(hasName("A"))))))));
  EXPECT_TRUE(matches("template <typename T> class A {};"
                      "template <typename T> class B { A<T> a; };",
                      fieldDecl(hasType(templateSpecializationType(
                        hasDeclaration(namedDecl(hasName("A"))))))));
  EXPECT_TRUE(matches("template <typename T> class A {}; A<int> a;",
                      varDecl(hasType(templateSpecializationType(
                          hasDeclaration(cxxRecordDecl()))))));
}

TEST(HasDeclaration, HasDeclarationOfCXXNewExpr) {
  EXPECT_TRUE(
      matches("int *A = new int();",
              cxxNewExpr(hasDeclaration(functionDecl(parameterCountIs(1))))));
}

TEST(HasDeclaration, HasDeclarationOfTypeAlias) {
  EXPECT_TRUE(matches("template <typename T> using C = T; C<int> c;",
                      varDecl(hasType(templateSpecializationType(
                          hasDeclaration(typeAliasTemplateDecl()))))));
}

TEST(HasUnqualifiedDesugaredType, DesugarsUsing) {
  EXPECT_TRUE(
      matches("struct A {}; using B = A; B b;",
              varDecl(hasType(hasUnqualifiedDesugaredType(recordType())))));
  EXPECT_TRUE(
      matches("struct A {}; using B = A; using C = B; C b;",
              varDecl(hasType(hasUnqualifiedDesugaredType(recordType())))));
}

TEST(HasUnderlyingDecl, Matches) {
  EXPECT_TRUE(matches("namespace N { template <class T> void f(T t); }"
                      "template <class T> void g() { using N::f; f(T()); }",
                      unresolvedLookupExpr(hasAnyDeclaration(
                          namedDecl(hasUnderlyingDecl(hasName("::N::f")))))));
  EXPECT_TRUE(matches(
      "namespace N { template <class T> void f(T t); }"
      "template <class T> void g() { N::f(T()); }",
      unresolvedLookupExpr(hasAnyDeclaration(namedDecl(hasName("::N::f"))))));
  EXPECT_TRUE(notMatches(
      "namespace N { template <class T> void f(T t); }"
      "template <class T> void g() { using N::f; f(T()); }",
      unresolvedLookupExpr(hasAnyDeclaration(namedDecl(hasName("::N::f"))))));
}

TEST(HasType, TakesQualTypeMatcherAndMatchesExpr) {
  TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
  EXPECT_TRUE(
    matches("class X {}; void y(X &x) { x; }", expr(hasType(ClassX))));
  EXPECT_TRUE(
    notMatches("class X {}; void y(X *x) { x; }",
               expr(hasType(ClassX))));
  EXPECT_TRUE(
    matches("class X {}; void y(X *x) { x; }",
            expr(hasType(pointsTo(ClassX)))));
}

TEST(HasType, TakesQualTypeMatcherAndMatchesValueDecl) {
  TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
  EXPECT_TRUE(
    matches("class X {}; void y() { X x; }", varDecl(hasType(ClassX))));
  EXPECT_TRUE(
    notMatches("class X {}; void y() { X *x; }", varDecl(hasType(ClassX))));
  EXPECT_TRUE(
    matches("class X {}; void y() { X *x; }",
            varDecl(hasType(pointsTo(ClassX)))));
}

TEST(HasType, TakesQualTypeMatcherAndMatchesCXXBaseSpecifier) {
  TypeMatcher ClassX = hasDeclaration(recordDecl(hasName("X")));
  CXXBaseSpecifierMatcher BaseClassX = cxxBaseSpecifier(hasType(ClassX));
  DeclarationMatcher ClassHasBaseClassX =
      cxxRecordDecl(hasDirectBase(BaseClassX));
  EXPECT_TRUE(matches("class X {}; class Y : X {};", ClassHasBaseClassX));
  EXPECT_TRUE(notMatches("class Z {}; class Y : Z {};", ClassHasBaseClassX));
}

TEST(HasType, TakesDeclMatcherAndMatchesExpr) {
  DeclarationMatcher ClassX = recordDecl(hasName("X"));
  EXPECT_TRUE(
    matches("class X {}; void y(X &x) { x; }", expr(hasType(ClassX))));
  EXPECT_TRUE(
    notMatches("class X {}; void y(X *x) { x; }",
               expr(hasType(ClassX))));
}

TEST(HasType, TakesDeclMatcherAndMatchesValueDecl) {
  DeclarationMatcher ClassX = recordDecl(hasName("X"));
  EXPECT_TRUE(
    matches("class X {}; void y() { X x; }", varDecl(hasType(ClassX))));
  EXPECT_TRUE(
    notMatches("class X {}; void y() { X *x; }", varDecl(hasType(ClassX))));
}

TEST(HasType, TakesDeclMatcherAndMatchesCXXBaseSpecifier) {
  DeclarationMatcher ClassX = recordDecl(hasName("X"));
  CXXBaseSpecifierMatcher BaseClassX = cxxBaseSpecifier(hasType(ClassX));
  DeclarationMatcher ClassHasBaseClassX =
      cxxRecordDecl(hasDirectBase(BaseClassX));
  EXPECT_TRUE(matches("class X {}; class Y : X {};", ClassHasBaseClassX));
  EXPECT_TRUE(notMatches("class Z {}; class Y : Z {};", ClassHasBaseClassX));
}

TEST(HasType, MatchesTypedefDecl) {
  EXPECT_TRUE(matches("typedef int X;", typedefDecl(hasType(asString("int")))));
  EXPECT_TRUE(matches("typedef const int T;",
                      typedefDecl(hasType(asString("const int")))));
  EXPECT_TRUE(notMatches("typedef const int T;",
                         typedefDecl(hasType(asString("int")))));
  EXPECT_TRUE(matches("typedef int foo; typedef foo bar;",
                      typedefDecl(hasType(asString("foo")), hasName("bar"))));
}

TEST(HasType, MatchesTypedefNameDecl) {
  EXPECT_TRUE(matches("using X = int;", typedefNameDecl(hasType(asString("int")))));
  EXPECT_TRUE(matches("using T = const int;",
                      typedefNameDecl(hasType(asString("const int")))));
  EXPECT_TRUE(notMatches("using T = const int;",
                         typedefNameDecl(hasType(asString("int")))));
  EXPECT_TRUE(matches("using foo = int; using bar = foo;",
                      typedefNameDecl(hasType(asString("foo")), hasName("bar"))));
}

TEST(HasTypeLoc, MatchesBlockDecl) {
  EXPECT_TRUE(matchesConditionally(
      "auto x = ^int (int a, int b) { return a + b; };",
      blockDecl(hasTypeLoc(loc(asString("int (int, int)")))), true,
      {"-fblocks"}));
}

TEST(HasTypeLoc, MatchesCXXBaseSpecifierAndCtorInitializer) {
  llvm::StringRef code = R"cpp(
  class Foo {};
  class Bar : public Foo {
    Bar() : Foo() {}
  };
  )cpp";

  EXPECT_TRUE(matches(
      code, cxxRecordDecl(hasAnyBase(hasTypeLoc(loc(asString("class Foo")))))));
  EXPECT_TRUE(matches(
      code, cxxCtorInitializer(hasTypeLoc(loc(asString("class Foo"))))));
}

TEST(HasTypeLoc, MatchesCXXFunctionalCastExpr) {
  EXPECT_TRUE(matches("auto x = int(3);",
                      cxxFunctionalCastExpr(hasTypeLoc(loc(asString("int"))))));
}

TEST(HasTypeLoc, MatchesCXXNewExpr) {
  EXPECT_TRUE(matches("auto* x = new int(3);",
                      cxxNewExpr(hasTypeLoc(loc(asString("int"))))));
  EXPECT_TRUE(matches("class Foo{}; auto* x = new Foo();",
                      cxxNewExpr(hasTypeLoc(loc(asString("class Foo"))))));
}

TEST(HasTypeLoc, MatchesCXXTemporaryObjectExpr) {
  EXPECT_TRUE(
      matches("struct Foo { Foo(int, int); }; auto x = Foo(1, 2);",
              cxxTemporaryObjectExpr(hasTypeLoc(loc(asString("struct Foo"))))));
}

TEST(HasTypeLoc, MatchesCXXUnresolvedConstructExpr) {
  EXPECT_TRUE(
      matches("template <typename T> T make() { return T(); }",
              cxxUnresolvedConstructExpr(hasTypeLoc(loc(asString("T"))))));
}

TEST(HasTypeLoc, MatchesClassTemplateSpecializationDecl) {
  EXPECT_TRUE(matches(
      "template <typename T> class Foo; template <> class Foo<int> {};",
      classTemplateSpecializationDecl(hasTypeLoc(loc(asString("Foo<int>"))))));
}

TEST(HasTypeLoc, MatchesCompoundLiteralExpr) {
  EXPECT_TRUE(
      matches("int* x = (int[2]) { 0, 1 };",
              compoundLiteralExpr(hasTypeLoc(loc(asString("int[2]"))))));
}

TEST(HasTypeLoc, MatchesDeclaratorDecl) {
  EXPECT_TRUE(matches("int x;",
                      varDecl(hasName("x"), hasTypeLoc(loc(asString("int"))))));
  EXPECT_TRUE(matches("int x(3);",
                      varDecl(hasName("x"), hasTypeLoc(loc(asString("int"))))));
  EXPECT_TRUE(
      matches("struct Foo { Foo(int, int); }; Foo x(1, 2);",
              varDecl(hasName("x"), hasTypeLoc(loc(asString("struct Foo"))))));

  // Make sure we don't crash on implicit constructors.
  EXPECT_TRUE(notMatches("class X {}; X x;",
                         declaratorDecl(hasTypeLoc(loc(asString("int"))))));
}

TEST(HasTypeLoc, MatchesExplicitCastExpr) {
  EXPECT_TRUE(matches("auto x = (int) 3;",
                      explicitCastExpr(hasTypeLoc(loc(asString("int"))))));
  EXPECT_TRUE(matches("auto x = static_cast<int>(3);",
                      explicitCastExpr(hasTypeLoc(loc(asString("int"))))));
}

TEST(HasTypeLoc, MatchesObjCPropertyDecl) {
  EXPECT_TRUE(matchesObjC(R"objc(
      @interface Foo
      @property int enabled;
      @end
    )objc",
                          objcPropertyDecl(hasTypeLoc(loc(asString("int"))))));
}

TEST(HasTypeLoc, MatchesTemplateArgumentLoc) {
  EXPECT_TRUE(matches("template <typename T> class Foo {}; Foo<int> x;",
                      templateArgumentLoc(hasTypeLoc(loc(asString("int"))))));
}

TEST(HasTypeLoc, MatchesTypedefNameDecl) {
  EXPECT_TRUE(matches("typedef int X;",
                      typedefNameDecl(hasTypeLoc(loc(asString("int"))))));
  EXPECT_TRUE(matches("using X = int;",
                      typedefNameDecl(hasTypeLoc(loc(asString("int"))))));
}

TEST(Callee, MatchesDeclarations) {
  StatementMatcher CallMethodX = callExpr(callee(cxxMethodDecl(hasName("x"))));

  EXPECT_TRUE(matches("class Y { void x() { x(); } };", CallMethodX));
  EXPECT_TRUE(notMatches("class Y { void x() {} };", CallMethodX));

  CallMethodX = traverse(TK_AsIs, callExpr(callee(cxxConversionDecl())));
  EXPECT_TRUE(
    matches("struct Y { operator int() const; }; int i = Y();", CallMethodX));
  EXPECT_TRUE(notMatches("struct Y { operator int() const; }; Y y = Y();",
                         CallMethodX));
}

TEST(Callee, MatchesMemberExpressions) {
  EXPECT_TRUE(matches("class Y { void x() { this->x(); } };",
                      callExpr(callee(memberExpr()))));
  EXPECT_TRUE(
    notMatches("class Y { void x() { this->x(); } };", callExpr(callee(callExpr()))));
}

TEST(Matcher, Argument) {
  StatementMatcher CallArgumentY = callExpr(
    hasArgument(0, declRefExpr(to(varDecl(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 = callExpr(
    hasArgument(42, declRefExpr(to(varDecl(hasName("y"))))));
  EXPECT_TRUE(notMatches("void x(int) { int y; x(y); }", WrongIndex));
}

TEST(Matcher, AnyArgument) {
  auto HasArgumentY = hasAnyArgument(
      ignoringParenImpCasts(declRefExpr(to(varDecl(hasName("y"))))));
  StatementMatcher CallArgumentY = callExpr(HasArgumentY);
  StatementMatcher CtorArgumentY = cxxConstructExpr(HasArgumentY);
  StatementMatcher UnresolvedCtorArgumentY =
      cxxUnresolvedConstructExpr(HasArgumentY);
  StatementMatcher ObjCCallArgumentY = objcMessageExpr(HasArgumentY);
  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(matches("struct Y { Y(int, int); };"
                      "void x() { int y; (void)Y(1, y); }",
                      CtorArgumentY));
  EXPECT_TRUE(matches("struct Y { Y(int, int); };"
                      "void x() { int y; (void)Y(y, 42); }",
                      CtorArgumentY));
  EXPECT_TRUE(matches("template <class Y> void x() { int y; (void)Y(1, y); }",
                      UnresolvedCtorArgumentY));
  EXPECT_TRUE(matches("template <class Y> void x() { int y; (void)Y(y, 42); }",
                      UnresolvedCtorArgumentY));
  EXPECT_TRUE(matchesObjC("@interface I -(void)f:(int) y; @end "
                          "void x(I* i) { int y; [i f:y]; }",
                          ObjCCallArgumentY));
  EXPECT_FALSE(matchesObjC("@interface I -(void)f:(int) z; @end "
                           "void x(I* i) { int z; [i f:z]; }",
                           ObjCCallArgumentY));
  EXPECT_TRUE(notMatches("void x(int, int) { x(1, 2); }", CallArgumentY));
  EXPECT_TRUE(notMatches("struct Y { Y(int, int); };"
                         "void x() { int y; (void)Y(1, 2); }",
                         CtorArgumentY));
  EXPECT_TRUE(notMatches("template <class Y>"
                         "void x() { int y; (void)Y(1, 2); }",
                         UnresolvedCtorArgumentY));

  StatementMatcher ImplicitCastedArgument =
      traverse(TK_AsIs, callExpr(hasAnyArgument(implicitCastExpr())));
  EXPECT_TRUE(matches("void x(long) { int y; x(y); }", ImplicitCastedArgument));
}

TEST(Matcher, HasReceiver) {
  EXPECT_TRUE(matchesObjC(
      "@interface NSString @end "
      "void f(NSString *x) {"
      "[x containsString];"
      "}",
      objcMessageExpr(hasReceiver(declRefExpr(to(varDecl(hasName("x"))))))));

  EXPECT_FALSE(matchesObjC(
      "@interface NSString +(NSString *) stringWithFormat; @end "
      "void f() { [NSString stringWithFormat]; }",
      objcMessageExpr(hasReceiver(declRefExpr(to(varDecl(hasName("x"))))))));
}

TEST(Matcher, MatchesMethodsOnLambda) {
  StringRef Code = R"cpp(
struct A {
  ~A() {}
};
void foo()
{
  A a;
  auto l = [a] { };
  auto lCopy = l;
  auto lPtrDecay = +[] { };
  (void)lPtrDecay;
}
)cpp";

  EXPECT_TRUE(matches(
      Code, cxxConstructorDecl(
                hasBody(compoundStmt()),
                hasAncestor(lambdaExpr(hasAncestor(varDecl(hasName("l"))))),
                isCopyConstructor())));
  EXPECT_TRUE(matches(
      Code, cxxConstructorDecl(
                hasBody(compoundStmt()),
                hasAncestor(lambdaExpr(hasAncestor(varDecl(hasName("l"))))),
                isMoveConstructor())));
  EXPECT_TRUE(matches(
      Code, cxxDestructorDecl(
                hasBody(compoundStmt()),
                hasAncestor(lambdaExpr(hasAncestor(varDecl(hasName("l"))))))));
  EXPECT_TRUE(matches(
      Code, cxxConversionDecl(hasBody(compoundStmt(has(returnStmt(
                                  hasReturnValue(implicitCastExpr()))))),
                              hasAncestor(lambdaExpr(hasAncestor(
                                  varDecl(hasName("lPtrDecay"))))))));
}

TEST(Matcher, MatchesCoroutine) {
  FileContentMappings M;
  M.push_back(std::make_pair("/coro_header", R"cpp(
namespace std {

template <class... Args>
struct void_t_imp {
  using type = void;
};
template <class... Args>
using void_t = typename void_t_imp<Args...>::type;

template <class T, class = void>
struct traits_sfinae_base {};

template <class T>
struct traits_sfinae_base<T, void_t<typename T::promise_type>> {
  using promise_type = typename T::promise_type;
};

template <class Ret, class... Args>
struct coroutine_traits : public traits_sfinae_base<Ret> {};
}  // namespace std
struct awaitable {
  bool await_ready() noexcept;
  template <typename F>
  void await_suspend(F) noexcept;
  void await_resume() noexcept;
} a;
struct promise {
  void get_return_object();
  awaitable initial_suspend();
  awaitable final_suspend() noexcept;
  awaitable yield_value(int); // expected-note 2{{candidate}}
  void return_value(int); // expected-note 2{{here}}
  void unhandled_exception();
};
template <typename... T>
struct std::coroutine_traits<void, T...> { using promise_type = promise; };
namespace std {
template <class PromiseType = void>
struct coroutine_handle {
  static coroutine_handle from_address(void *) noexcept;
};
} // namespace std
)cpp"));
  StringRef CoReturnCode = R"cpp(
#include <coro_header>
void check_match_co_return() {
  co_return 1;
}
)cpp";
  EXPECT_TRUE(matchesConditionally(CoReturnCode, 
                                   coreturnStmt(isExpansionInMainFile()), 
                                   true, {"-std=c++20", "-I/"}, M));
  StringRef CoAwaitCode = R"cpp(
#include <coro_header>
void check_match_co_await() {
  co_await a;
}
)cpp";
  EXPECT_TRUE(matchesConditionally(CoAwaitCode, 
                                   coawaitExpr(isExpansionInMainFile()), 
                                   true, {"-std=c++20", "-I/"}, M));
  StringRef CoYieldCode = R"cpp(
#include <coro_header>
void check_match_co_yield() {
  co_yield 1.0;
}
)cpp";
  EXPECT_TRUE(matchesConditionally(CoYieldCode, 
                                   coyieldExpr(isExpansionInMainFile()), 
                                   true, {"-std=c++20", "-I/"}, M));
}

TEST(Matcher, isClassMessage) {
  EXPECT_TRUE(matchesObjC(
      "@interface NSString +(NSString *) stringWithFormat; @end "
      "void f() { [NSString stringWithFormat]; }",
      objcMessageExpr(isClassMessage())));

  EXPECT_FALSE(matchesObjC(
      "@interface NSString @end "
      "void f(NSString *x) {"
      "[x containsString];"
      "}",
      objcMessageExpr(isClassMessage())));
}

TEST(Matcher, isInstanceMessage) {
  EXPECT_TRUE(matchesObjC(
      "@interface NSString @end "
      "void f(NSString *x) {"
      "[x containsString];"
      "}",
      objcMessageExpr(isInstanceMessage())));

  EXPECT_FALSE(matchesObjC(
      "@interface NSString +(NSString *) stringWithFormat; @end "
      "void f() { [NSString stringWithFormat]; }",
      objcMessageExpr(isInstanceMessage())));

}

TEST(Matcher, isClassMethod) {
  EXPECT_TRUE(matchesObjC(
    "@interface Bar + (void)bar; @end",
    objcMethodDecl(isClassMethod())));

  EXPECT_TRUE(matchesObjC(
    "@interface Bar @end"
    "@implementation Bar + (void)bar {} @end",
    objcMethodDecl(isClassMethod())));

  EXPECT_FALSE(matchesObjC(
    "@interface Foo - (void)foo; @end",
    objcMethodDecl(isClassMethod())));

  EXPECT_FALSE(matchesObjC(
    "@interface Foo @end "
    "@implementation Foo - (void)foo {} @end",
    objcMethodDecl(isClassMethod())));
}

TEST(Matcher, isInstanceMethod) {
  EXPECT_TRUE(matchesObjC(
    "@interface Foo - (void)foo; @end",
    objcMethodDecl(isInstanceMethod())));

  EXPECT_TRUE(matchesObjC(
    "@interface Foo @end "
    "@implementation Foo - (void)foo {} @end",
    objcMethodDecl(isInstanceMethod())));

  EXPECT_FALSE(matchesObjC(
    "@interface Bar + (void)bar; @end",
    objcMethodDecl(isInstanceMethod())));

  EXPECT_FALSE(matchesObjC(
    "@interface Bar @end"
    "@implementation Bar + (void)bar {} @end",
    objcMethodDecl(isInstanceMethod())));
}

TEST(MatcherCXXMemberCallExpr, On) {
  StringRef Snippet1 = R"cc(
        struct Y {
          void m();
        };
        void z(Y y) { y.m(); }
      )cc";
  StringRef Snippet2 = R"cc(
        struct Y {
          void m();
        };
        struct X : public Y {};
        void z(X x) { x.m(); }
      )cc";
  auto MatchesY = cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("Y")))));
  EXPECT_TRUE(matches(Snippet1, MatchesY));
  EXPECT_TRUE(notMatches(Snippet2, MatchesY));

  auto MatchesX = cxxMemberCallExpr(on(hasType(cxxRecordDecl(hasName("X")))));
  EXPECT_TRUE(matches(Snippet2, MatchesX));

  // Parens are ignored.
  StringRef Snippet3 = R"cc(
    struct Y {
      void m();
    };
    Y g();
    void z(Y y) { (g()).m(); }
  )cc";
  auto MatchesCall = cxxMemberCallExpr(on(callExpr()));
  EXPECT_TRUE(matches(Snippet3, MatchesCall));
}

TEST(MatcherCXXMemberCallExpr, OnImplicitObjectArgument) {
  StringRef Snippet1 = R"cc(
    struct Y {
      void m();
    };
    void z(Y y) { y.m(); }
  )cc";
  StringRef Snippet2 = R"cc(
    struct Y {
      void m();
    };
    struct X : public Y {};
    void z(X x) { x.m(); }
  )cc";
  auto MatchesY = traverse(TK_AsIs, cxxMemberCallExpr(onImplicitObjectArgument(
                                        hasType(cxxRecordDecl(hasName("Y"))))));
  EXPECT_TRUE(matches(Snippet1, MatchesY));
  EXPECT_TRUE(matches(Snippet2, MatchesY));

  auto MatchesX = traverse(TK_AsIs, cxxMemberCallExpr(onImplicitObjectArgument(
                                        hasType(cxxRecordDecl(hasName("X"))))));
  EXPECT_TRUE(notMatches(Snippet2, MatchesX));

  // Parens are not ignored.
  StringRef Snippet3 = R"cc(
    struct Y {
      void m();
    };
    Y g();
    void z(Y y) { (g()).m(); }
  )cc";
  auto MatchesCall = traverse(
      TK_AsIs, cxxMemberCallExpr(onImplicitObjectArgument(callExpr())));
  EXPECT_TRUE(notMatches(Snippet3, MatchesCall));
}

TEST(Matcher, HasObjectExpr) {
  StringRef Snippet1 = R"cc(
        struct X {
          int m;
          int f(X x) { return x.m; }
        };
      )cc";
  StringRef Snippet2 = R"cc(
        struct X {
          int m;
          int f(X x) { return m; }
        };
      )cc";
  auto MatchesX =
      memberExpr(hasObjectExpression(hasType(cxxRecordDecl(hasName("X")))));
  EXPECT_TRUE(matches(Snippet1, MatchesX));
  EXPECT_TRUE(notMatches(Snippet2, MatchesX));

  auto MatchesXPointer = memberExpr(
      hasObjectExpression(hasType(pointsTo(cxxRecordDecl(hasName("X"))))));
  EXPECT_TRUE(notMatches(Snippet1, MatchesXPointer));
  EXPECT_TRUE(matches(Snippet2, MatchesXPointer));
}

TEST(ForEachArgumentWithParam, ReportsNoFalsePositives) {
  StatementMatcher ArgumentY =
    declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
  StatementMatcher CallExpr =
    callExpr(forEachArgumentWithParam(ArgumentY, IntParam));

  // IntParam does not match.
  EXPECT_TRUE(notMatches("void f(int* i) { int* y; f(y); }", CallExpr));
  // ArgumentY does not match.
  EXPECT_TRUE(notMatches("void f(int i) { int x; f(x); }", CallExpr));
}

TEST(ForEachArgumentWithParam, MatchesCXXMemberCallExpr) {
  StatementMatcher ArgumentY =
    declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
  StatementMatcher CallExpr =
    callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "struct S {"
      "  const S& operator[](int i) { return *this; }"
      "};"
      "void f(S S1) {"
      "  int y = 1;"
      "  S1[y];"
      "}",
    CallExpr, std::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 1)));

  StatementMatcher CallExpr2 =
    callExpr(forEachArgumentWithParam(ArgumentY, IntParam));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "struct S {"
      "  static void g(int i);"
      "};"
      "void f() {"
      "  int y = 1;"
      "  S::g(y);"
      "}",
    CallExpr2, std::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 1)));
}

TEST(ForEachArgumentWithParam, MatchesCallExpr) {
  StatementMatcher ArgumentY =
    declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
  StatementMatcher CallExpr =
    callExpr(forEachArgumentWithParam(ArgumentY, IntParam));

  EXPECT_TRUE(
    matchAndVerifyResultTrue("void f(int i) { int y; f(y); }", CallExpr,
                             std::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>(
                               "param")));
  EXPECT_TRUE(
    matchAndVerifyResultTrue("void f(int i) { int y; f(y); }", CallExpr,
                             std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>(
                               "arg")));

  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void f(int i, int j) { int y; f(y, y); }", CallExpr,
    std::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param", 2)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void f(int i, int j) { int y; f(y, y); }", CallExpr,
    std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg", 2)));
}

TEST(ForEachArgumentWithParam, MatchesConstructExpr) {
  StatementMatcher ArgumentY =
    declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  DeclarationMatcher IntParam = parmVarDecl(hasType(isInteger())).bind("param");
  StatementMatcher ConstructExpr = traverse(
      TK_AsIs, cxxConstructExpr(forEachArgumentWithParam(ArgumentY, IntParam)));

  EXPECT_TRUE(matchAndVerifyResultTrue(
    "struct C {"
      "  C(int i) {}"
      "};"
      "int y = 0;"
      "C Obj(y);",
    ConstructExpr,
    std::make_unique<VerifyIdIsBoundTo<ParmVarDecl>>("param")));
}

TEST(ForEachArgumentWithParam, HandlesBoundNodesForNonMatches) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void g(int i, int j) {"
      "  int a;"
      "  int b;"
      "  int c;"
      "  g(a, 0);"
      "  g(a, b);"
      "  g(0, b);"
      "}",
    functionDecl(
      forEachDescendant(varDecl().bind("v")),
      forEachDescendant(callExpr(forEachArgumentWithParam(
        declRefExpr(to(decl(equalsBoundNode("v")))), parmVarDecl())))),
    std::make_unique<VerifyIdIsBoundTo<VarDecl>>("v", 4)));
}

TEST(ForEachArgumentWithParamType, ReportsNoFalsePositives) {
  StatementMatcher ArgumentY =
      declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  TypeMatcher IntType = qualType(isInteger()).bind("type");
  StatementMatcher CallExpr =
      callExpr(forEachArgumentWithParamType(ArgumentY, IntType));

  // IntParam does not match.
  EXPECT_TRUE(notMatches("void f(int* i) { int* y; f(y); }", CallExpr));
  // ArgumentY does not match.
  EXPECT_TRUE(notMatches("void f(int i) { int x; f(x); }", CallExpr));
}

TEST(ForEachArgumentWithParamType, MatchesCXXMemberCallExpr) {
  StatementMatcher ArgumentY =
      declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  TypeMatcher IntType = qualType(isInteger()).bind("type");
  StatementMatcher CallExpr =
      callExpr(forEachArgumentWithParamType(ArgumentY, IntType));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "struct S {"
      "  const S& operator[](int i) { return *this; }"
      "};"
      "void f(S S1) {"
      "  int y = 1;"
      "  S1[y];"
      "}",
      CallExpr, std::make_unique<VerifyIdIsBoundTo<QualType>>("type", 1)));

  StatementMatcher CallExpr2 =
      callExpr(forEachArgumentWithParamType(ArgumentY, IntType));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "struct S {"
      "  static void g(int i);"
      "};"
      "void f() {"
      "  int y = 1;"
      "  S::g(y);"
      "}",
      CallExpr2, std::make_unique<VerifyIdIsBoundTo<QualType>>("type", 1)));
}

TEST(ForEachArgumentWithParamType, MatchesCallExpr) {
  StatementMatcher ArgumentY =
      declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  TypeMatcher IntType = qualType(isInteger()).bind("type");
  StatementMatcher CallExpr =
      callExpr(forEachArgumentWithParamType(ArgumentY, IntType));

  EXPECT_TRUE(matchAndVerifyResultTrue(
      "void f(int i) { int y; f(y); }", CallExpr,
      std::make_unique<VerifyIdIsBoundTo<QualType>>("type")));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "void f(int i) { int y; f(y); }", CallExpr,
      std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg")));

  EXPECT_TRUE(matchAndVerifyResultTrue(
      "void f(int i, int j) { int y; f(y, y); }", CallExpr,
      std::make_unique<VerifyIdIsBoundTo<QualType>>("type", 2)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "void f(int i, int j) { int y; f(y, y); }", CallExpr,
      std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg", 2)));
}

TEST(ForEachArgumentWithParamType, MatchesConstructExpr) {
  StatementMatcher ArgumentY =
      declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  TypeMatcher IntType = qualType(isInteger()).bind("type");
  StatementMatcher ConstructExpr =
      cxxConstructExpr(forEachArgumentWithParamType(ArgumentY, IntType));

  EXPECT_TRUE(matchAndVerifyResultTrue(
      "struct C {"
      "  C(int i) {}"
      "};"
      "int y = 0;"
      "C Obj(y);",
      ConstructExpr, std::make_unique<VerifyIdIsBoundTo<QualType>>("type")));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "struct C {"
      "  C(int i) {}"
      "};"
      "int y = 0;"
      "C Obj(y);",
      ConstructExpr, std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg")));
}

TEST(ForEachArgumentWithParamType, HandlesKandRFunctions) {
  StatementMatcher ArgumentY =
      declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  TypeMatcher IntType = qualType(isInteger()).bind("type");
  StatementMatcher CallExpr =
      callExpr(forEachArgumentWithParamType(ArgumentY, IntType));

  EXPECT_TRUE(matchesC("void f();\n"
                       "void call_it(void) { int x, y; f(x, y); }\n"
                       "void f(a, b) int a, b; {}\n"
                       "void call_it2(void) { int x, y; f(x, y); }",
                       CallExpr));
}

TEST(ForEachArgumentWithParamType, HandlesBoundNodesForNonMatches) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "void g(int i, int j) {"
      "  int a;"
      "  int b;"
      "  int c;"
      "  g(a, 0);"
      "  g(a, b);"
      "  g(0, b);"
      "}",
      functionDecl(
          forEachDescendant(varDecl().bind("v")),
          forEachDescendant(callExpr(forEachArgumentWithParamType(
              declRefExpr(to(decl(equalsBoundNode("v")))), qualType())))),
      std::make_unique<VerifyIdIsBoundTo<VarDecl>>("v", 4)));
}

TEST(ForEachArgumentWithParamType, MatchesFunctionPtrCalls) {
  StatementMatcher ArgumentY =
      declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  TypeMatcher IntType = qualType(builtinType()).bind("type");
  StatementMatcher CallExpr =
      callExpr(forEachArgumentWithParamType(ArgumentY, IntType));

  EXPECT_TRUE(matchAndVerifyResultTrue(
      "void f(int i) {"
      "void (*f_ptr)(int) = f; int y; f_ptr(y); }",
      CallExpr, std::make_unique<VerifyIdIsBoundTo<QualType>>("type")));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "void f(int i) {"
      "void (*f_ptr)(int) = f; int y; f_ptr(y); }",
      CallExpr, std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg")));
}

TEST(ForEachArgumentWithParamType, MatchesMemberFunctionPtrCalls) {
  StatementMatcher ArgumentY =
      declRefExpr(to(varDecl(hasName("y")))).bind("arg");
  TypeMatcher IntType = qualType(builtinType()).bind("type");
  StatementMatcher CallExpr =
      callExpr(forEachArgumentWithParamType(ArgumentY, IntType));

  StringRef S = "struct A {\n"
                "  int f(int i) { return i + 1; }\n"
                "  int (A::*x)(int);\n"
                "};\n"
                "void f() {\n"
                "  int y = 42;\n"
                "  A a;\n"
                "  a.x = &A::f;\n"
                "  (a.*(a.x))(y);\n"
                "}";
  EXPECT_TRUE(matchAndVerifyResultTrue(
      S, CallExpr, std::make_unique<VerifyIdIsBoundTo<QualType>>("type")));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      S, CallExpr, std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("arg")));
}

TEST(QualType, hasCanonicalType) {
  EXPECT_TRUE(notMatches("typedef int &int_ref;"
                           "int a;"
                           "int_ref b = a;",
                         varDecl(hasType(qualType(referenceType())))));
  EXPECT_TRUE(
    matches("typedef int &int_ref;"
              "int a;"
              "int_ref b = a;",
            varDecl(hasType(qualType(hasCanonicalType(referenceType()))))));
}

TEST(HasParameter, CallsInnerMatcher) {
  EXPECT_TRUE(matches("class X { void x(int) {} };",
                      cxxMethodDecl(hasParameter(0, varDecl()))));
  EXPECT_TRUE(notMatches("class X { void x(int) {} };",
                         cxxMethodDecl(hasParameter(0, hasName("x")))));
  EXPECT_TRUE(matchesObjC("@interface I -(void)f:(int) x; @end",
                          objcMethodDecl(hasParameter(0, hasName("x")))));
  EXPECT_TRUE(matchesObjC("int main() { void (^b)(int) = ^(int p) {}; }",
                          blockDecl(hasParameter(0, hasName("p")))));
}

TEST(HasParameter, DoesNotMatchIfIndexOutOfBounds) {
  EXPECT_TRUE(notMatches("class X { void x(int) {} };",
                         cxxMethodDecl(hasParameter(42, varDecl()))));
}

TEST(HasType, MatchesParameterVariableTypesStrictly) {
  EXPECT_TRUE(matches(
    "class X { void x(X x) {} };",
    cxxMethodDecl(hasParameter(0, hasType(recordDecl(hasName("X")))))));
  EXPECT_TRUE(notMatches(
    "class X { void x(const X &x) {} };",
    cxxMethodDecl(hasParameter(0, hasType(recordDecl(hasName("X")))))));
  EXPECT_TRUE(matches("class X { void x(const X *x) {} };",
                      cxxMethodDecl(hasParameter(
                        0, hasType(pointsTo(recordDecl(hasName("X"))))))));
  EXPECT_TRUE(matches("class X { void x(const X &x) {} };",
                      cxxMethodDecl(hasParameter(
                        0, hasType(references(recordDecl(hasName("X"))))))));
}

TEST(HasAnyParameter, MatchesIndependentlyOfPosition) {
  EXPECT_TRUE(matches(
    "class Y {}; class X { void x(X x, Y y) {} };",
    cxxMethodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
  EXPECT_TRUE(matches(
    "class Y {}; class X { void x(Y y, X x) {} };",
    cxxMethodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
  EXPECT_TRUE(matchesObjC("@interface I -(void)f:(int) x; @end",
                          objcMethodDecl(hasAnyParameter(hasName("x")))));
  EXPECT_TRUE(matchesObjC("int main() { void (^b)(int) = ^(int p) {}; }",
                          blockDecl(hasAnyParameter(hasName("p")))));
}

TEST(Returns, MatchesReturnTypes) {
  EXPECT_TRUE(matches("class Y { int f() { return 1; } };",
                      functionDecl(returns(asString("int")))));
  EXPECT_TRUE(notMatches("class Y { int f() { return 1; } };",
                         functionDecl(returns(asString("float")))));
  EXPECT_TRUE(matches("class Y { Y getMe() { return *this; } };",
                      functionDecl(returns(hasDeclaration(
                        recordDecl(hasName("Y")))))));
}

TEST(HasAnyParameter, DoesntMatchIfInnerMatcherDoesntMatch) {
  EXPECT_TRUE(notMatches(
    "class Y {}; class X { void x(int) {} };",
    cxxMethodDecl(hasAnyParameter(hasType(recordDecl(hasName("X")))))));
}

TEST(HasAnyParameter, DoesNotMatchThisPointer) {
  EXPECT_TRUE(notMatches("class Y {}; class X { void x() {} };",
                         cxxMethodDecl(hasAnyParameter(
                           hasType(pointsTo(recordDecl(hasName("X"))))))));
}

TEST(HasName, MatchesParameterVariableDeclarations) {
  EXPECT_TRUE(matches("class Y {}; class X { void x(int x) {} };",
                      cxxMethodDecl(hasAnyParameter(hasName("x")))));
  EXPECT_TRUE(notMatches("class Y {}; class X { void x(int) {} };",
                         cxxMethodDecl(hasAnyParameter(hasName("x")))));
}

TEST(Matcher, MatchesTypeTemplateArgument) {
  EXPECT_TRUE(matches(
    "template<typename T> struct B {};"
      "B<int> b;",
    classTemplateSpecializationDecl(hasAnyTemplateArgument(refersToType(
      asString("int"))))));
}

TEST(Matcher, MatchesTemplateTemplateArgument) {
  EXPECT_TRUE(matches("template<template <typename> class S> class X {};"
                      "template<typename T> class Y {};"
                      "X<Y> xi;",
                      classTemplateSpecializationDecl(hasAnyTemplateArgument(
                          refersToTemplate(templateName())))));
}

TEST(Matcher, MatchesDeclarationReferenceTemplateArgument) {
  EXPECT_TRUE(matches(
    "struct B { int next; };"
      "template<int(B::*next_ptr)> struct A {};"
      "A<&B::next> a;",
    classTemplateSpecializationDecl(hasAnyTemplateArgument(
      refersToDeclaration(fieldDecl(hasName("next")))))));

  EXPECT_TRUE(notMatches(
    "template <typename T> struct A {};"
      "A<int> a;",
    classTemplateSpecializationDecl(hasAnyTemplateArgument(
      refersToDeclaration(decl())))));

  EXPECT_TRUE(matches(
    "struct B { int next; };"
      "template<int(B::*next_ptr)> struct A {};"
      "A<&B::next> a;",
    templateSpecializationType(hasAnyTemplateArgument(isExpr(
      hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))));

  EXPECT_TRUE(notMatches(
    "template <typename T> struct A {};"
      "A<int> a;",
    templateSpecializationType(hasAnyTemplateArgument(
      refersToDeclaration(decl())))));
}


TEST(Matcher, MatchesSpecificArgument) {
  EXPECT_TRUE(matches(
    "template<typename T, typename U> class A {};"
      "A<bool, int> a;",
    classTemplateSpecializationDecl(hasTemplateArgument(
      1, refersToType(asString("int"))))));
  EXPECT_TRUE(notMatches(
    "template<typename T, typename U> class A {};"
      "A<int, bool> a;",
    classTemplateSpecializationDecl(hasTemplateArgument(
      1, refersToType(asString("int"))))));

  EXPECT_TRUE(matches(
    "template<typename T, typename U> class A {};"
      "A<bool, int> a;",
    templateSpecializationType(hasTemplateArgument(
      1, refersToType(asString("int"))))));
  EXPECT_TRUE(notMatches(
    "template<typename T, typename U> class A {};"
      "A<int, bool> a;",
    templateSpecializationType(hasTemplateArgument(
      1, refersToType(asString("int"))))));

  EXPECT_TRUE(matches(
    "template<typename T> void f() {};"
      "void func() { f<int>(); }",
    functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))));
  EXPECT_TRUE(notMatches(
    "template<typename T> void f() {};",
    functionDecl(hasTemplateArgument(0, refersToType(asString("int"))))));
}

TEST(TemplateArgument, Matches) {
  EXPECT_TRUE(matches("template<typename T> struct C {}; C<int> c;",
                      classTemplateSpecializationDecl(
                        hasAnyTemplateArgument(templateArgument()))));
  EXPECT_TRUE(matches(
    "template<typename T> struct C {}; C<int> c;",
    templateSpecializationType(hasAnyTemplateArgument(templateArgument()))));

  EXPECT_TRUE(matches(
    "template<typename T> void f() {};"
      "void func() { f<int>(); }",
    functionDecl(hasAnyTemplateArgument(templateArgument()))));
}

TEST(TemplateTypeParmDecl, CXXMethodDecl) {
  const char input[] =
      "template<typename T>\n"
      "class Class {\n"
      "  void method();\n"
      "};\n"
      "template<typename U>\n"
      "void Class<U>::method() {}\n";
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
}

TEST(TemplateTypeParmDecl, VarDecl) {
  const char input[] =
      "template<typename T>\n"
      "class Class {\n"
      "  static T pi;\n"
      "};\n"
      "template<typename U>\n"
      "U Class<U>::pi = U(3.1415926535897932385);\n";
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
}

TEST(TemplateTypeParmDecl, VarTemplatePartialSpecializationDecl) {
  const char input[] =
      "template<typename T>\n"
      "struct Struct {\n"
      "  template<typename T2> static int field;\n"
      "};\n"
      "template<typename U>\n"
      "template<typename U2>\n"
      "int Struct<U>::field<U2*> = 123;\n";
  EXPECT_TRUE(
      matches(input, templateTypeParmDecl(hasName("T")), langCxx14OrLater()));
  EXPECT_TRUE(
      matches(input, templateTypeParmDecl(hasName("T2")), langCxx14OrLater()));
  EXPECT_TRUE(
      matches(input, templateTypeParmDecl(hasName("U")), langCxx14OrLater()));
  EXPECT_TRUE(
      matches(input, templateTypeParmDecl(hasName("U2")), langCxx14OrLater()));
}

TEST(TemplateTypeParmDecl, ClassTemplatePartialSpecializationDecl) {
  const char input[] =
      "template<typename T>\n"
      "class Class {\n"
      "  template<typename T2> struct Struct;\n"
      "};\n"
      "template<typename U>\n"
      "template<typename U2>\n"
      "struct Class<U>::Struct<U2*> {};\n";
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T2"))));
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U2"))));
}

TEST(TemplateTypeParmDecl, EnumDecl) {
  const char input[] =
      "template<typename T>\n"
      "struct Struct {\n"
      "  enum class Enum : T;\n"
      "};\n"
      "template<typename U>\n"
      "enum class Struct<U>::Enum : U {\n"
      "  e1,\n"
      "  e2\n"
      "};\n";
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
}

TEST(TemplateTypeParmDecl, RecordDecl) {
  const char input[] =
      "template<typename T>\n"
      "class Class {\n"
      "  struct Struct;\n"
      "};\n"
      "template<typename U>\n"
      "struct Class<U>::Struct {\n"
      "  U field;\n"
      "};\n";
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("T"))));
  EXPECT_TRUE(matches(input, templateTypeParmDecl(hasName("U"))));
}

TEST(RefersToIntegralType, Matches) {
  EXPECT_TRUE(matches("template<int T> struct C {}; C<42> c;",
                      classTemplateSpecializationDecl(
                        hasAnyTemplateArgument(refersToIntegralType(
                          asString("int"))))));
  EXPECT_TRUE(notMatches("template<unsigned T> struct C {}; C<42> c;",
                         classTemplateSpecializationDecl(hasAnyTemplateArgument(
                           refersToIntegralType(asString("int"))))));
}

TEST(ConstructorDeclaration, SimpleCase) {
  EXPECT_TRUE(matches("class Foo { Foo(int i); };",
                      cxxConstructorDecl(ofClass(hasName("Foo")))));
  EXPECT_TRUE(notMatches("class Foo { Foo(int i); };",
                         cxxConstructorDecl(ofClass(hasName("Bar")))));
}

TEST(DestructorDeclaration, MatchesVirtualDestructor) {
  EXPECT_TRUE(matches("class Foo { virtual ~Foo(); };",
                      cxxDestructorDecl(ofClass(hasName("Foo")))));
}

TEST(DestructorDeclaration, DoesNotMatchImplicitDestructor) {
  EXPECT_TRUE(notMatches("class Foo {};",
                         cxxDestructorDecl(ofClass(hasName("Foo")))));
}

TEST(HasAnyConstructorInitializer, SimpleCase) {
  EXPECT_TRUE(
    notMatches("class Foo { Foo() { } };",
               cxxConstructorDecl(hasAnyConstructorInitializer(anything()))));
  EXPECT_TRUE(
    matches("class Foo {"
              "  Foo() : foo_() { }"
              "  int foo_;"
              "};",
            cxxConstructorDecl(hasAnyConstructorInitializer(anything()))));
}

TEST(HasAnyConstructorInitializer, ForField) {
  static const char Code[] =
    "class Baz { };"
      "class Foo {"
      "  Foo() : foo_(), bar_() { }"
      "  Baz foo_;"
      "  struct {"
      "    Baz bar_;"
      "  };"
      "};";
  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
    forField(hasType(recordDecl(hasName("Baz"))))))));
  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
    forField(hasName("foo_"))))));
  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
    forField(hasName("bar_"))))));
  EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
    forField(hasType(recordDecl(hasName("Bar"))))))));
}

TEST(HasAnyConstructorInitializer, WithInitializer) {
  static const char Code[] =
    "class Foo {"
      "  Foo() : foo_(0) { }"
      "  int foo_;"
      "};";
  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
    withInitializer(integerLiteral(equals(0)))))));
  EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
    withInitializer(integerLiteral(equals(1)))))));
}

TEST(HasAnyConstructorInitializer, IsWritten) {
  static const char Code[] =
    "struct Bar { Bar(){} };"
      "class Foo {"
      "  Foo() : foo_() { }"
      "  Bar foo_;"
      "  Bar bar_;"
      "};";
  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
    allOf(forField(hasName("foo_")), isWritten())))));
  EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
    allOf(forField(hasName("bar_")), isWritten())))));
  EXPECT_TRUE(matches(Code, cxxConstructorDecl(hasAnyConstructorInitializer(
    allOf(forField(hasName("bar_")), unless(isWritten()))))));
}

TEST(HasAnyConstructorInitializer, IsBaseInitializer) {
  static const char Code[] =
    "struct B {};"
      "struct D : B {"
      "  int I;"
      "  D(int i) : I(i) {}"
      "};"
      "struct E : B {"
      "  E() : B() {}"
      "};";
  EXPECT_TRUE(matches(Code, cxxConstructorDecl(allOf(
    hasAnyConstructorInitializer(allOf(isBaseInitializer(), isWritten())),
    hasName("E")))));
  EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(allOf(
    hasAnyConstructorInitializer(allOf(isBaseInitializer(), isWritten())),
    hasName("D")))));
  EXPECT_TRUE(matches(Code, cxxConstructorDecl(allOf(
    hasAnyConstructorInitializer(allOf(isMemberInitializer(), isWritten())),
    hasName("D")))));
  EXPECT_TRUE(notMatches(Code, cxxConstructorDecl(allOf(
    hasAnyConstructorInitializer(allOf(isMemberInitializer(), isWritten())),
    hasName("E")))));
}

TEST(IfStmt, ChildTraversalMatchers) {
  EXPECT_TRUE(matches("void f() { if (false) true; else false; }",
                      ifStmt(hasThen(cxxBoolLiteral(equals(true))))));
  EXPECT_TRUE(notMatches("void f() { if (false) false; else true; }",
                         ifStmt(hasThen(cxxBoolLiteral(equals(true))))));
  EXPECT_TRUE(matches("void f() { if (false) false; else true; }",
                      ifStmt(hasElse(cxxBoolLiteral(equals(true))))));
  EXPECT_TRUE(notMatches("void f() { if (false) true; else false; }",
                         ifStmt(hasElse(cxxBoolLiteral(equals(true))))));
}

TEST(MatchBinaryOperator, HasOperatorName) {
  StatementMatcher OperatorOr = binaryOperator(hasOperatorName("||"));

  EXPECT_TRUE(matches("void x() { true || false; }", OperatorOr));
  EXPECT_TRUE(notMatches("void x() { true && false; }", OperatorOr));
}

TEST(MatchBinaryOperator, HasAnyOperatorName) {
  StatementMatcher Matcher =
      binaryOperator(hasAnyOperatorName("+", "-", "*", "/"));

  EXPECT_TRUE(matches("int x(int I) { return I + 2; }", Matcher));
  EXPECT_TRUE(matches("int x(int I) { return I - 2; }", Matcher));
  EXPECT_TRUE(matches("int x(int I) { return I * 2; }", Matcher));
  EXPECT_TRUE(matches("int x(int I) { return I / 2; }", Matcher));
  EXPECT_TRUE(notMatches("int x(int I) { return I % 2; }", Matcher));
  // Ensure '+= isn't mistaken.
  EXPECT_TRUE(notMatches("void x(int &I) { I += 1; }", Matcher));
}

TEST(MatchBinaryOperator, HasLHSAndHasRHS) {
  StatementMatcher OperatorTrueFalse =
    binaryOperator(hasLHS(cxxBoolLiteral(equals(true))),
                   hasRHS(cxxBoolLiteral(equals(false))));

  EXPECT_TRUE(matches("void x() { true || false; }", OperatorTrueFalse));
  EXPECT_TRUE(matches("void x() { true && false; }", OperatorTrueFalse));
  EXPECT_TRUE(notMatches("void x() { false || true; }", OperatorTrueFalse));

  StatementMatcher OperatorIntPointer = arraySubscriptExpr(
      hasLHS(hasType(isInteger())),
      traverse(TK_AsIs, hasRHS(hasType(pointsTo(qualType())))));
  EXPECT_TRUE(matches("void x() { 1[\"abc\"]; }", OperatorIntPointer));
  EXPECT_TRUE(notMatches("void x() { \"abc\"[1]; }", OperatorIntPointer));

  StringRef Code = R"cpp(
struct HasOpEqMem
{
    bool operator==(const HasOpEqMem& other) const
    {
        return true;
    }
};

struct HasOpFree
{
};
bool operator==(const HasOpFree& lhs, const HasOpFree& rhs)
{
    return true;
}

void opMem()
{
    HasOpEqMem s1;
    HasOpEqMem s2;
    if (s1 == s2)
        return;
}

void opFree()
{
    HasOpFree s1;
    HasOpFree s2;
    if (s1 == s2)
        return;
}
)cpp";
  auto s1Expr = declRefExpr(to(varDecl(hasName("s1"))));
  auto s2Expr = declRefExpr(to(varDecl(hasName("s2"))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               cxxOperatorCallExpr(forFunction(functionDecl(hasName("opMem"))),
                                   hasOperatorName("=="), hasLHS(s1Expr),
                                   hasRHS(s2Expr)))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     cxxOperatorCallExpr(
                         forFunction(functionDecl(hasName("opMem"))),
                         hasAnyOperatorName("!=", "=="), hasLHS(s1Expr)))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     cxxOperatorCallExpr(
                         forFunction(functionDecl(hasName("opMem"))),
                         hasOperatorName("=="), hasOperands(s1Expr, s2Expr)))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     cxxOperatorCallExpr(
                         forFunction(functionDecl(hasName("opMem"))),
                         hasOperatorName("=="), hasEitherOperand(s2Expr)))));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               cxxOperatorCallExpr(forFunction(functionDecl(hasName("opFree"))),
                                   hasOperatorName("=="), hasLHS(s1Expr),
                                   hasRHS(s2Expr)))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     cxxOperatorCallExpr(
                         forFunction(functionDecl(hasName("opFree"))),
                         hasAnyOperatorName("!=", "=="), hasLHS(s1Expr)))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     cxxOperatorCallExpr(
                         forFunction(functionDecl(hasName("opFree"))),
                         hasOperatorName("=="), hasOperands(s1Expr, s2Expr)))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     cxxOperatorCallExpr(
                         forFunction(functionDecl(hasName("opFree"))),
                         hasOperatorName("=="), hasEitherOperand(s2Expr)))));
}

TEST(MatchBinaryOperator, HasEitherOperand) {
  StatementMatcher HasOperand =
    binaryOperator(hasEitherOperand(cxxBoolLiteral(equals(false))));

  EXPECT_TRUE(matches("void x() { true || false; }", HasOperand));
  EXPECT_TRUE(matches("void x() { false && true; }", HasOperand));
  EXPECT_TRUE(notMatches("void x() { true || true; }", HasOperand));
}

TEST(MatchBinaryOperator, HasOperands) {
  StatementMatcher HasOperands = binaryOperator(
      hasOperands(integerLiteral(equals(1)), integerLiteral(equals(2))));
  EXPECT_TRUE(matches("void x() { 1 + 2; }", HasOperands));
  EXPECT_TRUE(matches("void x() { 2 + 1; }", HasOperands));
  EXPECT_TRUE(notMatches("void x() { 1 + 1; }", HasOperands));
  EXPECT_TRUE(notMatches("void x() { 2 + 2; }", HasOperands));
  EXPECT_TRUE(notMatches("void x() { 0 + 0; }", HasOperands));
  EXPECT_TRUE(notMatches("void x() { 0 + 1; }", HasOperands));
}

TEST(Matcher, BinaryOperatorTypes) {
  // Integration test that verifies the AST provides all binary operators in
  // a way we expect.
  // FIXME: Operator ','
  EXPECT_TRUE(
    matches("void x() { 3, 4; }", binaryOperator(hasOperatorName(","))));
  EXPECT_TRUE(
    matches("bool b; bool c = (b = true);",
            binaryOperator(hasOperatorName("="))));
  EXPECT_TRUE(
    matches("bool b = 1 != 2;", binaryOperator(hasOperatorName("!="))));
  EXPECT_TRUE(
    matches("bool b = 1 == 2;", binaryOperator(hasOperatorName("=="))));
  EXPECT_TRUE(matches("bool b = 1 < 2;", binaryOperator(hasOperatorName("<"))));
  EXPECT_TRUE(
    matches("bool b = 1 <= 2;", binaryOperator(hasOperatorName("<="))));
  EXPECT_TRUE(
    matches("int i = 1 << 2;", binaryOperator(hasOperatorName("<<"))));
  EXPECT_TRUE(
    matches("int i = 1; int j = (i <<= 2);",
            binaryOperator(hasOperatorName("<<="))));
  EXPECT_TRUE(matches("bool b = 1 > 2;", binaryOperator(hasOperatorName(">"))));
  EXPECT_TRUE(
    matches("bool b = 1 >= 2;", binaryOperator(hasOperatorName(">="))));
  EXPECT_TRUE(
    matches("int i = 1 >> 2;", binaryOperator(hasOperatorName(">>"))));
  EXPECT_TRUE(
    matches("int i = 1; int j = (i >>= 2);",
            binaryOperator(hasOperatorName(">>="))));
  EXPECT_TRUE(
    matches("int i = 42 ^ 23;", binaryOperator(hasOperatorName("^"))));
  EXPECT_TRUE(
    matches("int i = 42; int j = (i ^= 42);",
            binaryOperator(hasOperatorName("^="))));
  EXPECT_TRUE(
    matches("int i = 42 % 23;", binaryOperator(hasOperatorName("%"))));
  EXPECT_TRUE(
    matches("int i = 42; int j = (i %= 42);",
            binaryOperator(hasOperatorName("%="))));
  EXPECT_TRUE(
    matches("bool b = 42  &23;", binaryOperator(hasOperatorName("&"))));
  EXPECT_TRUE(
    matches("bool b = true && false;",
            binaryOperator(hasOperatorName("&&"))));
  EXPECT_TRUE(
    matches("bool b = true; bool c = (b &= false);",
            binaryOperator(hasOperatorName("&="))));
  EXPECT_TRUE(
    matches("bool b = 42 | 23;", binaryOperator(hasOperatorName("|"))));
  EXPECT_TRUE(
    matches("bool b = true || false;",
            binaryOperator(hasOperatorName("||"))));
  EXPECT_TRUE(
    matches("bool b = true; bool c = (b |= false);",
            binaryOperator(hasOperatorName("|="))));
  EXPECT_TRUE(
    matches("int i = 42  *23;", binaryOperator(hasOperatorName("*"))));
  EXPECT_TRUE(
    matches("int i = 42; int j = (i *= 23);",
            binaryOperator(hasOperatorName("*="))));
  EXPECT_TRUE(
    matches("int i = 42 / 23;", binaryOperator(hasOperatorName("/"))));
  EXPECT_TRUE(
    matches("int i = 42; int j = (i /= 23);",
            binaryOperator(hasOperatorName("/="))));
  EXPECT_TRUE(
    matches("int i = 42 + 23;", binaryOperator(hasOperatorName("+"))));
  EXPECT_TRUE(
    matches("int i = 42; int j = (i += 23);",
            binaryOperator(hasOperatorName("+="))));
  EXPECT_TRUE(
    matches("int i = 42 - 23;", binaryOperator(hasOperatorName("-"))));
  EXPECT_TRUE(
    matches("int i = 42; int j = (i -= 23);",
            binaryOperator(hasOperatorName("-="))));
  EXPECT_TRUE(
    matches("struct A { void x() { void (A::*a)(); (this->*a)(); } };",
            binaryOperator(hasOperatorName("->*"))));
  EXPECT_TRUE(
    matches("struct A { void x() { void (A::*a)(); ((*this).*a)(); } };",
            binaryOperator(hasOperatorName(".*"))));

  // Member expressions as operators are not supported in matches.
  EXPECT_TRUE(
    notMatches("struct A { void x(A *a) { a->x(this); } };",
               binaryOperator(hasOperatorName("->"))));

  // Initializer assignments are not represented as operator equals.
  EXPECT_TRUE(
    notMatches("bool b = true;", binaryOperator(hasOperatorName("="))));

  // Array indexing is not represented as operator.
  EXPECT_TRUE(notMatches("int a[42]; void x() { a[23]; }", unaryOperator()));

  // Overloaded operators do not match at all.
  EXPECT_TRUE(notMatches(
    "struct A { bool operator&&(const A &a) const { return false; } };"
      "void x() { A a, b; a && b; }",
    binaryOperator()));
}

TEST(MatchUnaryOperator, HasOperatorName) {
  StatementMatcher OperatorNot = unaryOperator(hasOperatorName("!"));

  EXPECT_TRUE(matches("void x() { !true; } ", OperatorNot));
  EXPECT_TRUE(notMatches("void x() { true; } ", OperatorNot));
}

TEST(MatchUnaryOperator, HasAnyOperatorName) {
  StatementMatcher Matcher = unaryOperator(hasAnyOperatorName("-", "*", "++"));

  EXPECT_TRUE(matches("int x(int *I) { return *I; }", Matcher));
  EXPECT_TRUE(matches("int x(int I) { return -I; }", Matcher));
  EXPECT_TRUE(matches("void x(int &I) { I++; }", Matcher));
  EXPECT_TRUE(matches("void x(int &I) { ++I; }", Matcher));
  EXPECT_TRUE(notMatches("void x(int &I) { I--; }", Matcher));
  EXPECT_TRUE(notMatches("void x(int &I) { --I; }", Matcher));
  EXPECT_TRUE(notMatches("int *x(int &I) { return &I; }", Matcher));
}

TEST(MatchUnaryOperator, HasUnaryOperand) {
  StatementMatcher OperatorOnFalse =
    unaryOperator(hasUnaryOperand(cxxBoolLiteral(equals(false))));

  EXPECT_TRUE(matches("void x() { !false; }", OperatorOnFalse));
  EXPECT_TRUE(notMatches("void x() { !true; }", OperatorOnFalse));

  StringRef Code = R"cpp(
struct HasOpBangMem
{
    bool operator!() const
    {
        return false;
    }
};
struct HasOpBangFree
{
};
bool operator!(HasOpBangFree const&)
{
    return false;
}

void opMem()
{
    HasOpBangMem s1;
    if (!s1)
        return;
}
void opFree()
{
    HasOpBangFree s1;
    if (!s1)
        return;
}
)cpp";
  auto s1Expr = declRefExpr(to(varDecl(hasName("s1"))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     cxxOperatorCallExpr(
                         forFunction(functionDecl(hasName("opMem"))),
                         hasOperatorName("!"), hasUnaryOperand(s1Expr)))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               cxxOperatorCallExpr(forFunction(functionDecl(hasName("opMem"))),
                                   hasAnyOperatorName("+", "!"),
                                   hasUnaryOperand(s1Expr)))));

  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     cxxOperatorCallExpr(
                         forFunction(functionDecl(hasName("opFree"))),
                         hasOperatorName("!"), hasUnaryOperand(s1Expr)))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               cxxOperatorCallExpr(forFunction(functionDecl(hasName("opFree"))),
                                   hasAnyOperatorName("+", "!"),
                                   hasUnaryOperand(s1Expr)))));

  Code = R"cpp(
struct HasIncOperatorsMem
{
    HasIncOperatorsMem& operator++();
    HasIncOperatorsMem operator++(int);
};
struct HasIncOperatorsFree
{
};
HasIncOperatorsFree& operator++(HasIncOperatorsFree&);
HasIncOperatorsFree operator++(HasIncOperatorsFree&, int);

void prefixIncOperatorMem()
{
    HasIncOperatorsMem s1;
    ++s1;
}
void prefixIncOperatorFree()
{
    HasIncOperatorsFree s1;
    ++s1;
}
void postfixIncOperatorMem()
{
    HasIncOperatorsMem s1;
    s1++;
}
void postfixIncOperatorFree()
{
    HasIncOperatorsFree s1;
    s1++;
}

struct HasOpPlusInt
{
    HasOpPlusInt& operator+(int);
};
void plusIntOperator()
{
    HasOpPlusInt s1;
    s1+1;
}
)cpp";

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               cxxOperatorCallExpr(
                   forFunction(functionDecl(hasName("prefixIncOperatorMem"))),
                   hasOperatorName("++"), hasUnaryOperand(declRefExpr())))));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               cxxOperatorCallExpr(
                   forFunction(functionDecl(hasName("prefixIncOperatorFree"))),
                   hasOperatorName("++"), hasUnaryOperand(declRefExpr())))));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               cxxOperatorCallExpr(
                   forFunction(functionDecl(hasName("postfixIncOperatorMem"))),
                   hasOperatorName("++"), hasUnaryOperand(declRefExpr())))));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               cxxOperatorCallExpr(
                   forFunction(functionDecl(hasName("postfixIncOperatorFree"))),
                   hasOperatorName("++"), hasUnaryOperand(declRefExpr())))));

  EXPECT_FALSE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     cxxOperatorCallExpr(
                         forFunction(functionDecl(hasName("plusIntOperator"))),
                         hasOperatorName("+"), hasUnaryOperand(expr())))));

  Code = R"cpp(
struct HasOpArrow
{
    int& operator*();
};
void foo()
{
    HasOpArrow s1;
    *s1;
}
)cpp";

  EXPECT_TRUE(
      matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
                             cxxOperatorCallExpr(hasOperatorName("*"),
                                                 hasUnaryOperand(expr())))));
}

TEST(Matcher, UnaryOperatorTypes) {
  // Integration test that verifies the AST provides all unary operators in
  // a way we expect.
  EXPECT_TRUE(matches("bool b = !true;", unaryOperator(hasOperatorName("!"))));
  EXPECT_TRUE(
    matches("bool b; bool *p = &b;", unaryOperator(hasOperatorName("&"))));
  EXPECT_TRUE(matches("int i = ~ 1;", unaryOperator(hasOperatorName("~"))));
  EXPECT_TRUE(
    matches("bool *p; bool b = *p;", unaryOperator(hasOperatorName("*"))));
  EXPECT_TRUE(
    matches("int i; int j = +i;", unaryOperator(hasOperatorName("+"))));
  EXPECT_TRUE(
    matches("int i; int j = -i;", unaryOperator(hasOperatorName("-"))));
  EXPECT_TRUE(
    matches("int i; int j = ++i;", unaryOperator(hasOperatorName("++"))));
  EXPECT_TRUE(
    matches("int i; int j = i++;", unaryOperator(hasOperatorName("++"))));
  EXPECT_TRUE(
    matches("int i; int j = --i;", unaryOperator(hasOperatorName("--"))));
  EXPECT_TRUE(
    matches("int i; int j = i--;", unaryOperator(hasOperatorName("--"))));

  // We don't match conversion operators.
  EXPECT_TRUE(notMatches("int i; double d = (double)i;", unaryOperator()));

  // Function calls are not represented as operator.
  EXPECT_TRUE(notMatches("void f(); void x() { f(); }", unaryOperator()));

  // Overloaded operators do not match at all.
  // FIXME: We probably want to add that.
  EXPECT_TRUE(notMatches(
    "struct A { bool operator!() const { return false; } };"
      "void x() { A a; !a; }", unaryOperator(hasOperatorName("!"))));
}

TEST(ArraySubscriptMatchers, ArrayIndex) {
  EXPECT_TRUE(matches(
    "int i[2]; void f() { i[1] = 1; }",
    arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
  EXPECT_TRUE(matches(
    "int i[2]; void f() { 1[i] = 1; }",
    arraySubscriptExpr(hasIndex(integerLiteral(equals(1))))));
  EXPECT_TRUE(notMatches(
    "int i[2]; void f() { i[1] = 1; }",
    arraySubscriptExpr(hasIndex(integerLiteral(equals(0))))));
}

TEST(ArraySubscriptMatchers, MatchesArrayBase) {
  EXPECT_TRUE(
      matches("int i[2]; void f() { i[1] = 2; }",
              traverse(TK_AsIs, arraySubscriptExpr(hasBase(implicitCastExpr(
                                    hasSourceExpression(declRefExpr())))))));
}

TEST(Matcher, OfClass) {
  StatementMatcher Constructor = cxxConstructExpr(hasDeclaration(cxxMethodDecl(
    ofClass(hasName("X")))));

  EXPECT_TRUE(
    matches("class X { public: X(); }; void x(int) { X x; }", Constructor));
  EXPECT_TRUE(
    matches("class X { public: X(); }; void x(int) { X x = X(); }",
            Constructor));
  EXPECT_TRUE(
    notMatches("class Y { public: Y(); }; void x(int) { Y y; }",
               Constructor));
}

TEST(Matcher, VisitsTemplateInstantiations) {
  EXPECT_TRUE(matches(
    "class A { public: void x(); };"
      "template <typename T> class B { public: void y() { T t; t.x(); } };"
      "void f() { B<A> b; b.y(); }",
    callExpr(callee(cxxMethodDecl(hasName("x"))))));

  EXPECT_TRUE(matches(
    "class A { public: void x(); };"
      "class C {"
      " public:"
      "  template <typename T> class B { public: void y() { T t; t.x(); } };"
      "};"
      "void f() {"
      "  C::B<A> b; b.y();"
      "}",
    recordDecl(hasName("C"), hasDescendant(callExpr(
      callee(cxxMethodDecl(hasName("x"))))))));
}

TEST(Matcher, HasCondition) {
  StatementMatcher IfStmt =
    ifStmt(hasCondition(cxxBoolLiteral(equals(true))));
  EXPECT_TRUE(matches("void x() { if (true) {} }", IfStmt));
  EXPECT_TRUE(notMatches("void x() { if (false) {} }", IfStmt));

  StatementMatcher ForStmt =
    forStmt(hasCondition(cxxBoolLiteral(equals(true))));
  EXPECT_TRUE(matches("void x() { for (;true;) {} }", ForStmt));
  EXPECT_TRUE(notMatches("void x() { for (;false;) {} }", ForStmt));

  StatementMatcher WhileStmt =
    whileStmt(hasCondition(cxxBoolLiteral(equals(true))));
  EXPECT_TRUE(matches("void x() { while (true) {} }", WhileStmt));
  EXPECT_TRUE(notMatches("void x() { while (false) {} }", WhileStmt));

  StatementMatcher SwitchStmt =
    switchStmt(hasCondition(integerLiteral(equals(42))));
  EXPECT_TRUE(matches("void x() { switch (42) {case 42:;} }", SwitchStmt));
  EXPECT_TRUE(notMatches("void x() { switch (43) {case 43:;} }", SwitchStmt));
}

TEST(For, ForLoopInternals) {
  EXPECT_TRUE(matches("void f(){ int i; for (; i < 3 ; ); }",
                      forStmt(hasCondition(anything()))));
  EXPECT_TRUE(matches("void f() { for (int i = 0; ;); }",
                      forStmt(hasLoopInit(anything()))));
}

TEST(For, ForRangeLoopInternals) {
  EXPECT_TRUE(matches("void f(){ int a[] {1, 2}; for (int i : a); }",
                      cxxForRangeStmt(hasLoopVariable(anything()))));
  EXPECT_TRUE(matches(
    "void f(){ int a[] {1, 2}; for (int i : a); }",
    cxxForRangeStmt(hasRangeInit(declRefExpr(to(varDecl(hasName("a"))))))));
}

TEST(For, NegativeForLoopInternals) {
  EXPECT_TRUE(notMatches("void f(){ for (int i = 0; ; ++i); }",
                         forStmt(hasCondition(expr()))));
  EXPECT_TRUE(notMatches("void f() {int i; for (; i < 4; ++i) {} }",
                         forStmt(hasLoopInit(anything()))));
}

TEST(HasBody, FindsBodyOfForWhileDoLoops) {
  EXPECT_TRUE(matches("void f() { for(;;) {} }",
                      forStmt(hasBody(compoundStmt()))));
  EXPECT_TRUE(notMatches("void f() { for(;;); }",
                         forStmt(hasBody(compoundStmt()))));
  EXPECT_TRUE(matches("void f() { while(true) {} }",
                      whileStmt(hasBody(compoundStmt()))));
  EXPECT_TRUE(matches("void f() { do {} while(true); }",
                      doStmt(hasBody(compoundStmt()))));
  EXPECT_TRUE(matches("void f() { int p[2]; for (auto x : p) {} }",
                      cxxForRangeStmt(hasBody(compoundStmt()))));
}

TEST(HasBody, FindsBodyOfFunctions) {
  EXPECT_TRUE(matches("void f() {}", functionDecl(hasBody(compoundStmt()))));
  EXPECT_TRUE(notMatches("void f();", functionDecl(hasBody(compoundStmt()))));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "void f(); void f() {}",
      functionDecl(hasBody(compoundStmt())).bind("func"),
      std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("func", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "class C { void f(); }; void C::f() {}",
      cxxMethodDecl(hasBody(compoundStmt())).bind("met"),
      std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("met", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "class C { C(); }; C::C() {}",
      cxxConstructorDecl(hasBody(compoundStmt())).bind("ctr"),
      std::make_unique<VerifyIdIsBoundTo<CXXConstructorDecl>>("ctr", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "class C { ~C(); }; C::~C() {}",
      cxxDestructorDecl(hasBody(compoundStmt())).bind("dtr"),
      std::make_unique<VerifyIdIsBoundTo<CXXDestructorDecl>>("dtr", 1)));
}

TEST(HasAnyBody, FindsAnyBodyOfFunctions) {
  EXPECT_TRUE(matches("void f() {}", functionDecl(hasAnyBody(compoundStmt()))));
  EXPECT_TRUE(notMatches("void f();",
                         functionDecl(hasAnyBody(compoundStmt()))));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "void f(); void f() {}",
      functionDecl(hasAnyBody(compoundStmt())).bind("func"),
      std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("func", 2)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "class C { void f(); }; void C::f() {}",
      cxxMethodDecl(hasAnyBody(compoundStmt())).bind("met"),
      std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("met", 2)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "class C { C(); }; C::C() {}",
      cxxConstructorDecl(hasAnyBody(compoundStmt())).bind("ctr"),
      std::make_unique<VerifyIdIsBoundTo<CXXConstructorDecl>>("ctr", 2)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "class C { ~C(); }; C::~C() {}",
      cxxDestructorDecl(hasAnyBody(compoundStmt())).bind("dtr"),
      std::make_unique<VerifyIdIsBoundTo<CXXDestructorDecl>>("dtr", 2)));
}

TEST(HasAnySubstatement, MatchesForTopLevelCompoundStatement) {
  // The simplest case: every compound statement is in a function
  // definition, and the function body itself must be a compound
  // statement.
  EXPECT_TRUE(matches("void f() { for (;;); }",
                      compoundStmt(hasAnySubstatement(forStmt()))));
}

TEST(HasAnySubstatement, IsNotRecursive) {
  // It's really "has any immediate substatement".
  EXPECT_TRUE(notMatches("void f() { if (true) for (;;); }",
                         compoundStmt(hasAnySubstatement(forStmt()))));
}

TEST(HasAnySubstatement, MatchesInNestedCompoundStatements) {
  EXPECT_TRUE(matches("void f() { if (true) { for (;;); } }",
                      compoundStmt(hasAnySubstatement(forStmt()))));
}

TEST(HasAnySubstatement, FindsSubstatementBetweenOthers) {
  EXPECT_TRUE(matches("void f() { 1; 2; 3; for (;;); 4; 5; 6; }",
                      compoundStmt(hasAnySubstatement(forStmt()))));
}

TEST(Member, MatchesMemberAllocationFunction) {
  // Fails in C++11 mode
  EXPECT_TRUE(matchesConditionally(
      "namespace std { typedef typeof(sizeof(int)) size_t; }"
      "class X { void *operator new(std::size_t); };",
      cxxMethodDecl(ofClass(hasName("X"))), true, {"-std=gnu++03"}));

  EXPECT_TRUE(matches("class X { void operator delete(void*); };",
                      cxxMethodDecl(ofClass(hasName("X")))));

  // Fails in C++11 mode
  EXPECT_TRUE(matchesConditionally(
      "namespace std { typedef typeof(sizeof(int)) size_t; }"
      "class X { void operator delete[](void*, std::size_t); };",
      cxxMethodDecl(ofClass(hasName("X"))), true, {"-std=gnu++03"}));
}

TEST(HasDestinationType, MatchesSimpleCase) {
  EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
                      cxxStaticCastExpr(hasDestinationType(
                        pointsTo(TypeMatcher(anything()))))));
}

TEST(HasImplicitDestinationType, MatchesSimpleCase) {
  // This test creates an implicit const cast.
  EXPECT_TRUE(matches(
      "int x; const int i = x;",
      traverse(TK_AsIs,
               implicitCastExpr(hasImplicitDestinationType(isInteger())))));
  // This test creates an implicit array-to-pointer cast.
  EXPECT_TRUE(
      matches("int arr[3]; int *p = arr;",
              traverse(TK_AsIs, implicitCastExpr(hasImplicitDestinationType(
                                    pointsTo(TypeMatcher(anything())))))));
}

TEST(HasImplicitDestinationType, DoesNotMatchIncorrectly) {
  // This test creates an implicit cast from int to char.
  EXPECT_TRUE(notMatches("char c = 0;",
                         implicitCastExpr(hasImplicitDestinationType(
                           unless(anything())))));
  // This test creates an implicit array-to-pointer cast.
  EXPECT_TRUE(notMatches("int arr[3]; int *p = arr;",
                         implicitCastExpr(hasImplicitDestinationType(
                           unless(anything())))));
}

TEST(Matcher, IgnoresElidableConstructors) {
  EXPECT_TRUE(
      matches("struct H {};"
              "template<typename T> H B(T A);"
              "void f() {"
              "  H D1;"
              "  D1 = B(B(1));"
              "}",
              cxxOperatorCallExpr(hasArgument(
                  1, callExpr(hasArgument(
                         0, ignoringElidableConstructorCall(callExpr()))))),
              langCxx11OrLater()));
  EXPECT_TRUE(
      matches("struct H {};"
              "template<typename T> H B(T A);"
              "void f() {"
              "  H D1;"
              "  D1 = B(1);"
              "}",
              cxxOperatorCallExpr(hasArgument(
                  1, callExpr(hasArgument(0, ignoringElidableConstructorCall(
                                                 integerLiteral()))))),
              langCxx11OrLater()));
  EXPECT_TRUE(matches(
      "struct H {};"
      "H G();"
      "void f() {"
      "  H D = G();"
      "}",
      varDecl(hasInitializer(anyOf(
          ignoringElidableConstructorCall(callExpr()),
          exprWithCleanups(has(ignoringElidableConstructorCall(callExpr())))))),
      langCxx11OrLater()));
}

TEST(Matcher, IgnoresElidableInReturn) {
  auto matcher = expr(ignoringElidableConstructorCall(declRefExpr()));
  EXPECT_TRUE(matches("struct H {};"
                      "H f() {"
                      "  H g;"
                      "  return g;"
                      "}",
                      matcher, langCxx11OrLater()));
  EXPECT_TRUE(notMatches("struct H {};"
                         "H f() {"
                         "  return H();"
                         "}",
                         matcher, langCxx11OrLater()));
}

TEST(Matcher, IgnoreElidableConstructorDoesNotMatchConstructors) {
  EXPECT_TRUE(matches("struct H {};"
                      "void f() {"
                      "  H D;"
                      "}",
                      varDecl(hasInitializer(
                          ignoringElidableConstructorCall(cxxConstructExpr()))),
                      langCxx11OrLater()));
}

TEST(Matcher, IgnoresElidableDoesNotPreventMatches) {
  EXPECT_TRUE(matches("void f() {"
                      "  int D = 10;"
                      "}",
                      expr(ignoringElidableConstructorCall(integerLiteral())),
                      langCxx11OrLater()));
}

TEST(Matcher, IgnoresElidableInVarInit) {
  auto matcher =
      varDecl(hasInitializer(ignoringElidableConstructorCall(callExpr())));
  EXPECT_TRUE(matches("struct H {};"
                      "H G();"
                      "void f(H D = G()) {"
                      "  return;"
                      "}",
                      matcher, langCxx11OrLater()));
  EXPECT_TRUE(matches("struct H {};"
                      "H G();"
                      "void f() {"
                      "  H D = G();"
                      "}",
                      matcher, langCxx11OrLater()));
}

TEST(IgnoringImplicit, MatchesImplicit) {
  EXPECT_TRUE(matches("class C {}; C a = C();",
                      varDecl(has(ignoringImplicit(cxxConstructExpr())))));
}

TEST(IgnoringImplicit, MatchesNestedImplicit) {
  StringRef Code = 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();
}
)";
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_AsIs,
               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();",
                         traverse(TK_AsIs, varDecl(has(cxxConstructExpr())))));
}

TEST(Traversal, traverseMatcher) {

  StringRef VarDeclCode = R"cpp(
void foo()
{
  int i = 3.0;
}
)cpp";

  auto Matcher = varDecl(hasInitializer(floatLiteral()));

  EXPECT_TRUE(notMatches(VarDeclCode, traverse(TK_AsIs, Matcher)));
  EXPECT_TRUE(
      matches(VarDeclCode, traverse(TK_IgnoreUnlessSpelledInSource, Matcher)));

  auto ParentMatcher = floatLiteral(hasParent(varDecl(hasName("i"))));

  EXPECT_TRUE(notMatches(VarDeclCode, traverse(TK_AsIs, ParentMatcher)));
  EXPECT_TRUE(matches(VarDeclCode,
                      traverse(TK_IgnoreUnlessSpelledInSource, ParentMatcher)));

  EXPECT_TRUE(matches(
      VarDeclCode, decl(traverse(TK_AsIs, anyOf(cxxRecordDecl(), varDecl())))));

  EXPECT_TRUE(
      matches(VarDeclCode,
              floatLiteral(traverse(TK_AsIs, hasParent(implicitCastExpr())))));

  EXPECT_TRUE(
      matches(VarDeclCode, floatLiteral(traverse(TK_IgnoreUnlessSpelledInSource,
                                                 hasParent(varDecl())))));

  EXPECT_TRUE(
      matches(VarDeclCode, varDecl(traverse(TK_IgnoreUnlessSpelledInSource,
                                            unless(parmVarDecl())))));

  EXPECT_TRUE(
      notMatches(VarDeclCode, varDecl(traverse(TK_IgnoreUnlessSpelledInSource,
                                               has(implicitCastExpr())))));

  EXPECT_TRUE(matches(VarDeclCode,
                      varDecl(traverse(TK_AsIs, has(implicitCastExpr())))));

  EXPECT_TRUE(matches(
      VarDeclCode, traverse(TK_IgnoreUnlessSpelledInSource,
                            // The has() below strips away the ImplicitCastExpr
                            // before the traverse(AsIs) gets to process it.
                            varDecl(has(traverse(TK_AsIs, floatLiteral()))))));

  EXPECT_TRUE(
      matches(VarDeclCode, functionDecl(traverse(TK_AsIs, hasName("foo")))));

  EXPECT_TRUE(matches(
      VarDeclCode,
      functionDecl(traverse(TK_IgnoreUnlessSpelledInSource, hasName("foo")))));

  EXPECT_TRUE(matches(
      VarDeclCode, functionDecl(traverse(TK_AsIs, hasAnyName("foo", "bar")))));

  EXPECT_TRUE(
      matches(VarDeclCode, functionDecl(traverse(TK_IgnoreUnlessSpelledInSource,
                                                 hasAnyName("foo", "bar")))));

  StringRef Code = R"cpp(
void foo(int a)
{
  int i = 3.0 + a;
}
void bar()
{
  foo(7.0);
}
)cpp";
  EXPECT_TRUE(
      matches(Code, callExpr(traverse(TK_IgnoreUnlessSpelledInSource,
                                      hasArgument(0, floatLiteral())))));

  EXPECT_TRUE(
      matches(Code, callExpr(traverse(TK_IgnoreUnlessSpelledInSource,
                                      hasAnyArgument(floatLiteral())))));

  EXPECT_TRUE(matches(
      R"cpp(
void takesBool(bool){}

template <typename T>
void neverInstantiatedTemplate() {
  takesBool(T{});
}
)cpp",
      traverse(TK_IgnoreUnlessSpelledInSource,
               callExpr(unless(callExpr(hasDeclaration(functionDecl())))))));

  EXPECT_TRUE(
      matches(VarDeclCode, varDecl(traverse(TK_IgnoreUnlessSpelledInSource,
                                            hasType(builtinType())))));

  EXPECT_TRUE(
      matches(VarDeclCode,
              functionDecl(hasName("foo"),
                           traverse(TK_AsIs, hasDescendant(floatLiteral())))));

  EXPECT_TRUE(notMatches(
      Code, traverse(TK_AsIs, floatLiteral(hasParent(callExpr(
                                  callee(functionDecl(hasName("foo")))))))));
  EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
                                     floatLiteral(hasParent(callExpr(callee(
                                         functionDecl(hasName("foo")))))))));

  Code = R"cpp(
void foo()
{
  int i = (3);
}
)cpp";
  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     varDecl(hasInitializer(integerLiteral(equals(3)))))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               integerLiteral(equals(3), hasParent(varDecl(hasName("i")))))));

  Code = R"cpp(
const char *SomeString{"str"};
)cpp";
  EXPECT_TRUE(
      matches(Code, traverse(TK_AsIs, stringLiteral(hasParent(implicitCastExpr(
                                          hasParent(initListExpr())))))));
  EXPECT_TRUE(
      matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
                             stringLiteral(hasParent(initListExpr())))));

  Code = R"cpp(
struct String
{
    String(const char*, int = -1) {}
};

void stringConstruct()
{
    String s = "foo";
    s = "bar";
}
)cpp";
  EXPECT_TRUE(matches(
      Code,
      traverse(
          TK_AsIs,
          functionDecl(
              hasName("stringConstruct"),
              hasDescendant(varDecl(
                  hasName("s"),
                  hasInitializer(ignoringImplicit(cxxConstructExpr(hasArgument(
                      0, ignoringImplicit(cxxConstructExpr(hasArgument(
                             0, ignoringImplicit(stringLiteral()))))))))))))));

  EXPECT_TRUE(matches(
      Code,
      traverse(
          TK_AsIs,
          functionDecl(hasName("stringConstruct"),
                       hasDescendant(cxxOperatorCallExpr(
                           isAssignmentOperator(),
                           hasArgument(1, ignoringImplicit(
                            cxxConstructExpr(hasArgument(
                               0, ignoringImplicit(stringLiteral())))))
                           ))))));

  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     functionDecl(hasName("stringConstruct"),
                                  hasDescendant(varDecl(
                                      hasName("s"),
                                      hasInitializer(stringLiteral())))))));

  EXPECT_TRUE(
      matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
                             functionDecl(hasName("stringConstruct"),
                                          hasDescendant(cxxOperatorCallExpr(
                                              isAssignmentOperator(),
                                              hasArgument(1, stringLiteral())))))));

  Code = R"cpp(

struct C1 {};
struct C2 { operator C1(); };

void conversionOperator()
{
    C2* c2;
    C1 c1 = (*c2);
}

)cpp";
  EXPECT_TRUE(matches(
      Code,
      traverse(
          TK_AsIs,
          functionDecl(
              hasName("conversionOperator"),
              hasDescendant(
                  varDecl(
                      hasName("c1"),
                      hasInitializer(
                          ignoringImplicit(cxxConstructExpr(hasArgument(
                              0, ignoringImplicit(
                                     cxxMemberCallExpr(onImplicitObjectArgument(
                                         ignoringParenImpCasts(unaryOperator(
                                             hasOperatorName("*")))))))))))
                      .bind("c1"))))));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               functionDecl(hasName("conversionOperator"),
                            hasDescendant(varDecl(
                                hasName("c1"), hasInitializer(unaryOperator(
                                                   hasOperatorName("*")))))))));

  Code = R"cpp(

template <unsigned alignment>
void template_test() {
  static_assert(alignment, "");
}
void actual_template_test() {
  template_test<4>();
}

)cpp";
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_AsIs,
               staticAssertDecl(has(implicitCastExpr(has(
                   substNonTypeTemplateParmExpr(has(integerLiteral())))))))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     staticAssertDecl(has(declRefExpr(
                         to(nonTypeTemplateParmDecl(hasName("alignment"))),
                         hasType(asString("unsigned int"))))))));

  EXPECT_TRUE(matches(Code, traverse(TK_AsIs, staticAssertDecl(hasDescendant(
                                                  integerLiteral())))));
  EXPECT_FALSE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                     staticAssertDecl(hasDescendant(integerLiteral())))));

  Code = R"cpp(

struct OneParamCtor {
  explicit OneParamCtor(int);
};
struct TwoParamCtor {
  explicit TwoParamCtor(int, int);
};

void varDeclCtors() {
  {
  auto var1 = OneParamCtor(5);
  auto var2 = TwoParamCtor(6, 7);
  }
  {
  OneParamCtor var3(5);
  TwoParamCtor var4(6, 7);
  }
  int i = 0;
  {
  auto var5 = OneParamCtor(i);
  auto var6 = TwoParamCtor(i, 7);
  }
  {
  OneParamCtor var7(i);
  TwoParamCtor var8(i, 7);
  }
}

)cpp";
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_AsIs, varDecl(hasName("var1"), hasInitializer(hasDescendant(
                                                     cxxConstructExpr()))))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_AsIs, varDecl(hasName("var2"), hasInitializer(hasDescendant(
                                                     cxxConstructExpr()))))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_AsIs, varDecl(hasName("var3"),
                                      hasInitializer(cxxConstructExpr())))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_AsIs, varDecl(hasName("var4"),
                                      hasInitializer(cxxConstructExpr())))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_AsIs, varDecl(hasName("var5"), hasInitializer(hasDescendant(
                                                     cxxConstructExpr()))))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_AsIs, varDecl(hasName("var6"), hasInitializer(hasDescendant(
                                                     cxxConstructExpr()))))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_AsIs, varDecl(hasName("var7"),
                                      hasInitializer(cxxConstructExpr())))));
  EXPECT_TRUE(matches(
      Code, traverse(TK_AsIs, varDecl(hasName("var8"),
                                      hasInitializer(cxxConstructExpr())))));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               varDecl(hasName("var1"), hasInitializer(cxxConstructExpr())))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               varDecl(hasName("var2"), hasInitializer(cxxConstructExpr())))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               varDecl(hasName("var3"), hasInitializer(cxxConstructExpr())))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               varDecl(hasName("var4"), hasInitializer(cxxConstructExpr())))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               varDecl(hasName("var5"), hasInitializer(cxxConstructExpr())))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               varDecl(hasName("var6"), hasInitializer(cxxConstructExpr())))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               varDecl(hasName("var7"), hasInitializer(cxxConstructExpr())))));
  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               varDecl(hasName("var8"), hasInitializer(cxxConstructExpr())))));

  Code = R"cpp(

template<typename T>
struct TemplStruct {
  TemplStruct() {}
  ~TemplStruct() {}

  void outOfLine(T);

private:
  T m_t;
};

template<typename T>
void TemplStruct<T>::outOfLine(T)
{

}

template<typename T>
T timesTwo(T input)
{
  return input * 2;
}

void instantiate()
{
  TemplStruct<int> ti;
  TemplStruct<double> td;
  (void)timesTwo<int>(2);
  (void)timesTwo<double>(2);
}

template class TemplStruct<float>;

extern template class TemplStruct<long>;

template<> class TemplStruct<bool> {
  TemplStruct() {}
  ~TemplStruct() {}

  void boolSpecializationMethodOnly() {}
private:
  bool m_t;
};

template float timesTwo(float);
template<> bool timesTwo<bool>(bool){
  return true;
}
)cpp";
  {
    auto M = cxxRecordDecl(hasName("TemplStruct"),
                           has(fieldDecl(hasType(asString("int")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxRecordDecl(hasName("TemplStruct"),
                           has(fieldDecl(hasType(asString("double")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M =
        functionDecl(hasName("timesTwo"),
                     hasParameter(0, parmVarDecl(hasType(asString("int")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M =
        functionDecl(hasName("timesTwo"),
                     hasParameter(0, parmVarDecl(hasType(asString("double")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    // Match on the integer literal in the explicit instantiation:
    auto MDef =
        functionDecl(hasName("timesTwo"),
                     hasParameter(0, parmVarDecl(hasType(asString("float")))),
                     hasDescendant(integerLiteral(equals(2))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MDef)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MDef)));

    auto MTempl =
        functionDecl(hasName("timesTwo"),
                     hasTemplateArgument(0, refersToType(asString("float"))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MTempl)));
    // TODO: If we could match on explicit instantiations of function templates,
    // this would be EXPECT_TRUE. See Sema::ActOnExplicitInstantiation.
    EXPECT_FALSE(
        matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MTempl)));
  }
  {
    auto M = functionDecl(hasName("timesTwo"),
                          hasParameter(0, parmVarDecl(hasType(booleanType()))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    // Match on the field within the explicit instantiation:
    auto MRecord = cxxRecordDecl(hasName("TemplStruct"),
                                 has(fieldDecl(hasType(asString("float")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MRecord)));
    EXPECT_FALSE(
        matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MRecord)));

    // Match on the explicit template instantiation itself:
    auto MTempl = classTemplateSpecializationDecl(
        hasName("TemplStruct"),
        hasTemplateArgument(0,
                            templateArgument(refersToType(asString("float")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MTempl)));
    EXPECT_TRUE(
        matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MTempl)));
  }
  {
    // The template argument is matchable, but the instantiation is not:
    auto M = classTemplateSpecializationDecl(
        hasName("TemplStruct"),
        hasTemplateArgument(0,
                            templateArgument(refersToType(asString("float")))),
        has(cxxConstructorDecl(hasName("TemplStruct"))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    // The template argument is matchable, but the instantiation is not:
    auto M = classTemplateSpecializationDecl(
        hasName("TemplStruct"),
        hasTemplateArgument(0,
                            templateArgument(refersToType(asString("long")))),
        has(cxxConstructorDecl(hasName("TemplStruct"))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    // Instantiated, out-of-line methods are not matchable.
    auto M =
        cxxMethodDecl(hasName("outOfLine"), isDefinition(),
                      hasParameter(0, parmVarDecl(hasType(asString("float")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    // Explicit specialization is written in source and it matches:
    auto M = classTemplateSpecializationDecl(
        hasName("TemplStruct"),
        hasTemplateArgument(0, templateArgument(refersToType(booleanType()))),
        has(cxxConstructorDecl(hasName("TemplStruct"))),
        has(cxxMethodDecl(hasName("boolSpecializationMethodOnly"))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }

  Code = R"cpp(
struct B {
  B(int);
};

B func1() { return 42; }
  )cpp";
  {
    auto M = expr(ignoringImplicit(integerLiteral(equals(42)).bind("intLit")));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_AsIs, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
  }
  {
    auto M = expr(unless(integerLiteral(equals(24)))).bind("intLit");
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_AsIs, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 6)));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
  }
  {
    auto M =
        expr(anyOf(integerLiteral(equals(42)).bind("intLit"), unless(expr())));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_AsIs, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
  }
  {
    auto M = expr(allOf(integerLiteral(equals(42)).bind("intLit"), expr()));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_AsIs, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
  }
  {
    auto M = expr(integerLiteral(equals(42)).bind("intLit"), expr());
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_AsIs, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
  }
  {
    auto M = expr(optionally(integerLiteral(equals(42)).bind("intLit")));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_AsIs, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("intLit", 1)));
  }
  {
    auto M = expr().bind("allExprs");
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_AsIs, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("allExprs", 6)));
    EXPECT_TRUE(matchAndVerifyResultTrue(
        Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
        std::make_unique<VerifyIdIsBoundTo<Expr>>("allExprs", 1)));
  }

  Code = R"cpp(
void foo()
{
    int arr[3];
    auto &[f, s, t] = arr;

    f = 42;
}
  )cpp";
  {
    auto M = bindingDecl(hasName("f"));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++17"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++17"}));
  }
  {
    auto M = bindingDecl(hasName("f"), has(expr()));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++17"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++17"}));
  }
  {
    auto M = integerLiteral(hasAncestor(bindingDecl(hasName("f"))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++17"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++17"}));
  }
  {
    auto M = declRefExpr(hasAncestor(bindingDecl(hasName("f"))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++17"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++17"}));
  }
}

TEST(Traversal, traverseNoImplicit) {
  StringRef Code = R"cpp(
struct NonTrivial {
    NonTrivial() {}
    NonTrivial(const NonTrivial&) {}
    NonTrivial& operator=(const NonTrivial&) { return *this; }

    ~NonTrivial() {}
};

struct NoSpecialMethods {
    NonTrivial nt;
};

struct ContainsArray {
    NonTrivial arr[2];
    ContainsArray& operator=(const ContainsArray &other) = default;
};

void copyIt()
{
    NoSpecialMethods nc1;
    NoSpecialMethods nc2(nc1);
    nc2 = nc1;

    ContainsArray ca;
    ContainsArray ca2;
    ca2 = ca;
}

struct HasCtorInits : NoSpecialMethods, NonTrivial
{
  int m_i;
  NonTrivial m_nt;
  HasCtorInits() : NoSpecialMethods(), m_i(42) {}
};

struct CtorInitsNonTrivial : NonTrivial
{
  int m_i;
  NonTrivial m_nt;
  CtorInitsNonTrivial() : NonTrivial(), m_i(42) {}
};

)cpp";
  {
    auto M = cxxRecordDecl(hasName("NoSpecialMethods"),
                           has(cxxRecordDecl(hasName("NoSpecialMethods"))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));

    M = cxxRecordDecl(hasName("NoSpecialMethods"),
                      has(cxxConstructorDecl(isCopyConstructor())));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));

    M = cxxRecordDecl(hasName("NoSpecialMethods"),
                      has(cxxMethodDecl(isCopyAssignmentOperator())));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));

    M = cxxRecordDecl(hasName("NoSpecialMethods"),
                      has(cxxConstructorDecl(isDefaultConstructor())));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));

    M = cxxRecordDecl(hasName("NoSpecialMethods"), has(cxxDestructorDecl()));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));

    M = cxxRecordDecl(hasName("NoSpecialMethods"),
                      hasMethod(cxxConstructorDecl(isCopyConstructor())));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));

    M = cxxRecordDecl(hasName("NoSpecialMethods"),
                      hasMethod(cxxMethodDecl(isCopyAssignmentOperator())));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));

    M = cxxRecordDecl(hasName("NoSpecialMethods"),
                      hasMethod(cxxConstructorDecl(isDefaultConstructor())));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));

    M = cxxRecordDecl(hasName("NoSpecialMethods"),
                      hasMethod(cxxDestructorDecl()));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    // Because the copy-assignment operator is not spelled in the
    // source (ie, isImplicit()), we don't match it
    auto M =
        cxxOperatorCallExpr(hasType(cxxRecordDecl(hasName("NoSpecialMethods"))),
                            callee(cxxMethodDecl(isCopyAssignmentOperator())));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    // Compiler generates a forStmt to copy the array
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, forStmt())));
    EXPECT_FALSE(
        matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, forStmt())));
  }
  {
    // The defaulted method declaration can be matched, but not its
    // definition, in IgnoreUnlessSpelledInSource mode
    auto MDecl = cxxMethodDecl(ofClass(cxxRecordDecl(hasName("ContainsArray"))),
                               isCopyAssignmentOperator(), isDefaulted());

    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MDecl)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MDecl)));

    auto MDef = cxxMethodDecl(MDecl, has(compoundStmt()));

    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MDef)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MDef)));

    auto MBody = cxxMethodDecl(MDecl, hasBody(compoundStmt()));

    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MBody)));
    EXPECT_FALSE(
        matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MBody)));

    auto MIsDefn = cxxMethodDecl(MDecl, isDefinition());

    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MIsDefn)));
    EXPECT_TRUE(
        matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MIsDefn)));

    auto MIsInline = cxxMethodDecl(MDecl, isInline());

    EXPECT_FALSE(matches(Code, traverse(TK_AsIs, MIsInline)));
    EXPECT_FALSE(
        matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MIsInline)));

    // The parameter of the defaulted method can still be matched.
    auto MParm =
        cxxMethodDecl(MDecl, hasParameter(0, parmVarDecl(hasName("other"))));

    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MParm)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MParm)));
  }
  {
    auto M =
        cxxConstructorDecl(hasName("HasCtorInits"),
                           has(cxxCtorInitializer(forField(hasName("m_i")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M =
        cxxConstructorDecl(hasName("HasCtorInits"),
                           has(cxxCtorInitializer(forField(hasName("m_nt")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxConstructorDecl(hasName("HasCtorInits"),
                                hasAnyConstructorInitializer(cxxCtorInitializer(
                                    forField(hasName("m_nt")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M =
        cxxConstructorDecl(hasName("HasCtorInits"),
                           forEachConstructorInitializer(
                               cxxCtorInitializer(forField(hasName("m_nt")))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxConstructorDecl(
        hasName("CtorInitsNonTrivial"),
        has(cxxCtorInitializer(withInitializer(cxxConstructExpr(
            hasDeclaration(cxxConstructorDecl(hasName("NonTrivial"))))))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxConstructorDecl(
        hasName("HasCtorInits"),
        has(cxxCtorInitializer(withInitializer(cxxConstructExpr(hasDeclaration(
            cxxConstructorDecl(hasName("NoSpecialMethods"))))))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxCtorInitializer(forField(hasName("m_nt")));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }

  Code = R"cpp(
  void rangeFor()
  {
    int arr[2];
    for (auto i : arr)
    {
      if (true)
      {
      }
    }
  }
  )cpp";
  {
    auto M = cxxForRangeStmt(has(binaryOperator(hasOperatorName("!="))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M =
        cxxForRangeStmt(hasDescendant(binaryOperator(hasOperatorName("+"))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M =
        cxxForRangeStmt(hasDescendant(unaryOperator(hasOperatorName("++"))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxForRangeStmt(has(declStmt()));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M =
        cxxForRangeStmt(hasLoopVariable(varDecl(hasName("i"))),
                        hasRangeInit(declRefExpr(to(varDecl(hasName("arr"))))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxForRangeStmt(unless(hasInitStatement(stmt())));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxForRangeStmt(hasBody(stmt()));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxForRangeStmt(hasDescendant(ifStmt()));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    EXPECT_TRUE(matches(
        Code, traverse(TK_AsIs, cxxForRangeStmt(has(declStmt(
                                    hasSingleDecl(varDecl(hasName("i")))))))));
    EXPECT_TRUE(
        matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
                               cxxForRangeStmt(has(varDecl(hasName("i")))))));
  }
  {
    EXPECT_TRUE(matches(
        Code, traverse(TK_AsIs, cxxForRangeStmt(has(declStmt(hasSingleDecl(
                                    varDecl(hasInitializer(declRefExpr(
                                        to(varDecl(hasName("arr")))))))))))));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
                                       cxxForRangeStmt(has(declRefExpr(
                                           to(varDecl(hasName("arr")))))))));
  }
  {
    auto M = cxxForRangeStmt(has(compoundStmt()));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = binaryOperator(hasOperatorName("!="));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = unaryOperator(hasOperatorName("++"));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = declStmt(hasSingleDecl(varDecl(matchesName("__range"))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = declStmt(hasSingleDecl(varDecl(matchesName("__begin"))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = declStmt(hasSingleDecl(varDecl(matchesName("__end"))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = ifStmt(hasParent(compoundStmt(hasParent(cxxForRangeStmt()))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxForRangeStmt(
        has(varDecl(hasName("i"), hasParent(cxxForRangeStmt()))));
    EXPECT_FALSE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxForRangeStmt(hasDescendant(varDecl(
        hasName("i"), hasParent(declStmt(hasParent(cxxForRangeStmt()))))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = cxxForRangeStmt(hasRangeInit(declRefExpr(
        to(varDecl(hasName("arr"))), hasParent(cxxForRangeStmt()))));
    EXPECT_FALSE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }

  {
    auto M = cxxForRangeStmt(hasRangeInit(declRefExpr(
        to(varDecl(hasName("arr"))), hasParent(varDecl(hasParent(declStmt(
                                         hasParent(cxxForRangeStmt()))))))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }

  Code = R"cpp(
  struct Range {
    int* begin() const;
    int* end() const;
  };
  Range getRange(int);

  void rangeFor()
  {
    for (auto i : getRange(42))
    {
    }
  }
  )cpp";
  {
    auto M = integerLiteral(equals(42));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = callExpr(hasDescendant(integerLiteral(equals(42))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = compoundStmt(hasDescendant(integerLiteral(equals(42))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }

  Code = R"cpp(
  void rangeFor()
  {
    int arr[2];
    for (auto& a = arr; auto i : a)
    {

    }
  }
  )cpp";
  {
    auto M = cxxForRangeStmt(has(binaryOperator(hasOperatorName("!="))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M =
        cxxForRangeStmt(hasDescendant(binaryOperator(hasOperatorName("+"))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M =
        cxxForRangeStmt(hasDescendant(unaryOperator(hasOperatorName("++"))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M =
        cxxForRangeStmt(has(declStmt(hasSingleDecl(varDecl(hasName("i"))))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = cxxForRangeStmt(
        hasInitStatement(declStmt(hasSingleDecl(varDecl(
            hasName("a"),
            hasInitializer(declRefExpr(to(varDecl(hasName("arr"))))))))),
        hasLoopVariable(varDecl(hasName("i"))),
        hasRangeInit(declRefExpr(to(varDecl(hasName("a"))))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = cxxForRangeStmt(
        has(declStmt(hasSingleDecl(varDecl(
            hasName("a"),
            hasInitializer(declRefExpr(to(varDecl(hasName("arr"))))))))),
        hasLoopVariable(varDecl(hasName("i"))),
        hasRangeInit(declRefExpr(to(varDecl(hasName("a"))))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = cxxForRangeStmt(hasInitStatement(declStmt(
        hasSingleDecl(varDecl(hasName("a"))), hasParent(cxxForRangeStmt()))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }

  Code = R"cpp(
  struct Range {
    int* begin() const;
    int* end() const;
  };
  Range getRange(int);

  int getNum(int);

  void rangeFor()
  {
    for (auto j = getNum(42); auto i : getRange(j))
    {
    }
  }
  )cpp";
  {
    auto M = integerLiteral(equals(42));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = compoundStmt(hasDescendant(integerLiteral(equals(42))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }

  Code = R"cpp(
void hasDefaultArg(int i, int j = 0)
{
}
void callDefaultArg()
{
  hasDefaultArg(42);
}
)cpp";
  auto hasDefaultArgCall = [](auto InnerMatcher) {
    return callExpr(callee(functionDecl(hasName("hasDefaultArg"))),
                    InnerMatcher);
  };
  {
    auto M = hasDefaultArgCall(has(integerLiteral(equals(42))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = hasDefaultArgCall(has(cxxDefaultArgExpr()));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = hasDefaultArgCall(argumentCountIs(2));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = hasDefaultArgCall(argumentCountIs(1));
    EXPECT_FALSE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = hasDefaultArgCall(hasArgument(1, cxxDefaultArgExpr()));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  {
    auto M = hasDefaultArgCall(hasAnyArgument(cxxDefaultArgExpr()));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  Code = R"cpp(
struct A
{
    ~A();
private:
    int i;
};

A::~A() = default;
)cpp";
  {
    auto M = cxxDestructorDecl(isDefaulted(),
                               ofClass(cxxRecordDecl(has(fieldDecl()))));
    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
    EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
  }
  Code = R"cpp(
struct S
{
    static constexpr bool getTrue() { return true; }
};

struct A
{
    explicit(S::getTrue()) A();
};

A::A() = default;
)cpp";
  {
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs,
                 cxxConstructorDecl(
                     isDefaulted(),
                     hasExplicitSpecifier(expr(ignoringImplicit(
                         callExpr(has(ignoringImplicit(declRefExpr())))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_IgnoreUnlessSpelledInSource,
                 cxxConstructorDecl(
                     isDefaulted(),
                     hasExplicitSpecifier(callExpr(has(declRefExpr()))))),
        true, {"-std=c++20"}));
  }
}

template <typename MatcherT>
bool matcherTemplateWithBinding(StringRef Code, const MatcherT &M) {
  return matchAndVerifyResultTrue(
      Code, M.bind("matchedStmt"),
      std::make_unique<VerifyIdIsBoundTo<ReturnStmt>>("matchedStmt", 1));
}

TEST(Traversal, traverseWithBinding) {
  // Some existing matcher code expects to take a matcher as a
  // template arg and bind to it.  Verify that that works.

  llvm::StringRef Code = R"cpp(
int foo()
{
  return 42.0;
}
)cpp";
  EXPECT_TRUE(matcherTemplateWithBinding(
      Code, traverse(TK_AsIs,
                     returnStmt(has(implicitCastExpr(has(floatLiteral())))))));
}

TEST(Traversal, traverseMatcherNesting) {

  StringRef Code = R"cpp(
float bar(int i)
{
  return i;
}

void foo()
{
  bar(bar(3.0));
}
)cpp";

  EXPECT_TRUE(
      matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
                             callExpr(has(callExpr(traverse(
                                 TK_AsIs, callExpr(has(implicitCastExpr(
                                              has(floatLiteral())))))))))));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               traverse(TK_AsIs, implicitCastExpr(has(floatLiteral()))))));
}

TEST(Traversal, traverseMatcherThroughImplicit) {
  StringRef Code = R"cpp(
struct S {
  S(int x);
};

void constructImplicit() {
  int a = 8;
  S s(a);
}
  )cpp";

  auto Matcher = traverse(TK_IgnoreUnlessSpelledInSource, implicitCastExpr());

  // Verfiy that it does not segfault
  EXPECT_FALSE(matches(Code, Matcher));
}

TEST(Traversal, traverseMatcherThroughMemoization) {

  StringRef Code = R"cpp(
void foo()
{
  int i = 3.0;
}
  )cpp";

  auto Matcher = varDecl(hasInitializer(floatLiteral()));

  // Matchers such as hasDescendant memoize their result regarding AST
  // nodes. In the matcher below, the first use of hasDescendant(Matcher)
  // fails, and the use of it inside the traverse() matcher should pass
  // causing the overall matcher to be a true match.
  // This test verifies that the first false result is not re-used, which
  // would cause the overall matcher to be incorrectly false.

  EXPECT_TRUE(matches(
      Code,
      functionDecl(anyOf(hasDescendant(Matcher),
                         traverse(TK_IgnoreUnlessSpelledInSource,
                                  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;
}

void func13() {
  int a = 0;
  int c = 0;

  [a, b = c](int d) { int e = d; };
}

void func14() {
  [] <typename TemplateType> (TemplateType t, TemplateType u) { int e = t + u; };
  float i = 42.0;
}

void func15() {
  int count = 0;
  auto l = [&] { ++count; };
  (void)l;
}

)cpp";

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       returnStmt(forFunction(functionDecl(hasName("func1"))),
                                  hasReturnValue(integerLiteral(equals(42))))),
              langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       integerLiteral(equals(42),
                                      hasParent(returnStmt(forFunction(
                                          functionDecl(hasName("func1"))))))),
              langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               returnStmt(forFunction(functionDecl(hasName("func2"))),
                          hasReturnValue(cxxTemporaryObjectExpr(
                              hasArgument(0, integerLiteral(equals(42))))))),
      langCxx20OrLater()));
  EXPECT_TRUE(matches(
      Code,
      traverse(
          TK_IgnoreUnlessSpelledInSource,
          integerLiteral(equals(42),
                         hasParent(cxxTemporaryObjectExpr(hasParent(returnStmt(
                             forFunction(functionDecl(hasName("func2"))))))))),
      langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       returnStmt(forFunction(functionDecl(hasName("func3"))),
                                  hasReturnValue(cxxConstructExpr(hasArgument(
                                      0, integerLiteral(equals(42))))))),
              langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(
          TK_IgnoreUnlessSpelledInSource,
          integerLiteral(equals(42),
                         hasParent(cxxConstructExpr(hasParent(returnStmt(
                             forFunction(functionDecl(hasName("func3"))))))))),
      langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       returnStmt(forFunction(functionDecl(hasName("func4"))),
                                  hasReturnValue(cxxTemporaryObjectExpr()))),
              langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       returnStmt(forFunction(functionDecl(hasName("func5"))),
                                  hasReturnValue(cxxTemporaryObjectExpr()))),
              langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       returnStmt(forFunction(functionDecl(hasName("func6"))),
                                  hasReturnValue(cxxTemporaryObjectExpr()))),
              langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       returnStmt(forFunction(functionDecl(hasName("func7"))),
                                  hasReturnValue(cxxTemporaryObjectExpr()))),
              langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       returnStmt(forFunction(functionDecl(hasName("func8"))),
                                  hasReturnValue(cxxFunctionalCastExpr(
                                      hasSourceExpression(initListExpr()))))),
              langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       returnStmt(forFunction(functionDecl(hasName("func9"))),
                                  hasReturnValue(cxxFunctionalCastExpr(
                                      hasSourceExpression(initListExpr()))))),
              langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(
          TK_IgnoreUnlessSpelledInSource,
          returnStmt(forFunction(functionDecl(hasName("func10"))),
                     hasReturnValue(declRefExpr(to(varDecl(hasName("a"))))))),
      langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       declRefExpr(to(varDecl(hasName("a"))),
                                   hasParent(returnStmt(forFunction(
                                       functionDecl(hasName("func10"))))))),
              langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(
          TK_IgnoreUnlessSpelledInSource,
          returnStmt(forFunction(functionDecl(hasName("func11"))),
                     hasReturnValue(declRefExpr(to(varDecl(hasName("b"))))))),
      langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       declRefExpr(to(varDecl(hasName("b"))),
                                   hasParent(returnStmt(forFunction(
                                       functionDecl(hasName("func11"))))))),
              langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(
          TK_IgnoreUnlessSpelledInSource,
          returnStmt(forFunction(functionDecl(hasName("func12"))),
                     hasReturnValue(declRefExpr(to(varDecl(hasName("c"))))))),
      langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       declRefExpr(to(varDecl(hasName("c"))),
                                   hasParent(returnStmt(forFunction(
                                       functionDecl(hasName("func12"))))))),
              langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(
          TK_IgnoreUnlessSpelledInSource,
          lambdaExpr(forFunction(functionDecl(hasName("func13"))),
                     has(compoundStmt(hasDescendant(varDecl(hasName("e"))))),
                     has(declRefExpr(to(varDecl(hasName("a"))))),
                     has(varDecl(hasName("b"), hasInitializer(declRefExpr(to(
                                                   varDecl(hasName("c"))))))),
                     has(parmVarDecl(hasName("d"))))),
      langCxx20OrLater()));

  EXPECT_TRUE(
      matches(Code,
              traverse(TK_IgnoreUnlessSpelledInSource,
                       declRefExpr(to(varDecl(hasName("a"))),
                                   hasParent(lambdaExpr(forFunction(
                                       functionDecl(hasName("func13"))))))),
              langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               varDecl(hasName("b"),
                       hasInitializer(declRefExpr(to(varDecl(hasName("c"))))),
                       hasParent(lambdaExpr(
                           forFunction(functionDecl(hasName("func13"))))))),
      langCxx20OrLater()));

  EXPECT_TRUE(matches(Code,
                      traverse(TK_IgnoreUnlessSpelledInSource,
                               compoundStmt(hasParent(lambdaExpr(forFunction(
                                   functionDecl(hasName("func13"))))))),
                      langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               templateTypeParmDecl(hasName("TemplateType"),
                                    hasParent(lambdaExpr(forFunction(
                                        functionDecl(hasName("func14"))))))),
      langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               lambdaExpr(forFunction(functionDecl(hasName("func14"))),
                          has(templateTypeParmDecl(hasName("TemplateType"))))),
      langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               functionDecl(hasName("func14"), hasDescendant(floatLiteral()))),
      langCxx20OrLater()));

  EXPECT_TRUE(matches(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               compoundStmt(
                   hasDescendant(varDecl(hasName("count")).bind("countVar")),
                   hasDescendant(
                       declRefExpr(to(varDecl(equalsBoundNode("countVar"))))))),
      langCxx20OrLater()));

  Code = R"cpp(
void foo() {
    int explicit_captured = 0;
    int implicit_captured = 0;
    auto l = [&, explicit_captured](int i) {
        if (i || explicit_captured || implicit_captured) return;
    };
}
)cpp";

  EXPECT_TRUE(matches(Code, traverse(TK_AsIs, ifStmt())));
  EXPECT_TRUE(
      matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, ifStmt())));

  auto lambdaExplicitCapture = declRefExpr(
      to(varDecl(hasName("explicit_captured"))), unless(hasAncestor(ifStmt())));
  auto lambdaImplicitCapture = declRefExpr(
      to(varDecl(hasName("implicit_captured"))), unless(hasAncestor(ifStmt())));

  EXPECT_TRUE(matches(Code, traverse(TK_AsIs, lambdaExplicitCapture)));
  EXPECT_TRUE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource, lambdaExplicitCapture)));

  EXPECT_TRUE(matches(Code, traverse(TK_AsIs, lambdaImplicitCapture)));
  EXPECT_FALSE(matches(
      Code, traverse(TK_IgnoreUnlessSpelledInSource, lambdaImplicitCapture)));

  Code = R"cpp(
struct S {};

struct HasOpEq
{
    bool operator==(const S& other)
    {
        return true;
    }
};

void binop()
{
    HasOpEq s1;
    S s2;
    if (s1 != s2)
        return;
}
)cpp";
  {
    auto M = unaryOperator(
        hasOperatorName("!"),
        has(cxxOperatorCallExpr(hasOverloadedOperatorName("=="))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = declRefExpr(to(varDecl(hasName("s1"))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = cxxOperatorCallExpr(hasOverloadedOperatorName("=="));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = cxxOperatorCallExpr(hasOverloadedOperatorName("!="));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  auto withDescendants = [](StringRef lName, StringRef rName) {
    return stmt(hasDescendant(declRefExpr(to(varDecl(hasName(lName))))),
                hasDescendant(declRefExpr(to(varDecl(hasName(rName))))));
  };
  {
    auto M = cxxRewrittenBinaryOperator(withDescendants("s1", "s2"));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = cxxRewrittenBinaryOperator(
        has(declRefExpr(to(varDecl(hasName("s1"))))),
        has(declRefExpr(to(varDecl(hasName("s2"))))));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = cxxRewrittenBinaryOperator(
        hasLHS(expr(hasParent(cxxRewrittenBinaryOperator()))),
        hasRHS(expr(hasParent(cxxRewrittenBinaryOperator()))));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName("!="), hasAnyOperatorName("<", "!="),
                     isComparisonOperator(),
                     hasLHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("s1")))))),
                     hasRHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("s2")))))),
                     hasEitherOperand(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("s2")))))),
                     hasOperands(ignoringImplicit(
                                     declRefExpr(to(varDecl(hasName("s1"))))),
                                 ignoringImplicit(declRefExpr(
                                     to(varDecl(hasName("s2")))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_IgnoreUnlessSpelledInSource,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName("!="), hasAnyOperatorName("<", "!="),
                     isComparisonOperator(),
                     hasLHS(declRefExpr(to(varDecl(hasName("s1"))))),
                     hasRHS(declRefExpr(to(varDecl(hasName("s2"))))),
                     hasEitherOperand(declRefExpr(to(varDecl(hasName("s2"))))),
                     hasOperands(declRefExpr(to(varDecl(hasName("s1")))),
                                 declRefExpr(to(varDecl(hasName("s2"))))))),
        true, {"-std=c++20"}));
  }

  Code = R"cpp(
namespace std {
struct strong_ordering {
  int n;
  constexpr operator int() const { return n; }
  static const strong_ordering equal, greater, less;
};
constexpr strong_ordering strong_ordering::equal = {0};
constexpr strong_ordering strong_ordering::greater = {1};
constexpr strong_ordering strong_ordering::less = {-1};
}

struct HasSpaceshipMem {
  int a;
  constexpr auto operator<=>(const HasSpaceshipMem&) const = default;
};

void binop()
{
    HasSpaceshipMem hs1, hs2;
    if (hs1 == hs2)
        return;

    HasSpaceshipMem hs3, hs4;
    if (hs3 != hs4)
        return;

    HasSpaceshipMem hs5, hs6;
    if (hs5 < hs6)
        return;

    HasSpaceshipMem hs7, hs8;
    if (hs7 > hs8)
        return;

    HasSpaceshipMem hs9, hs10;
    if (hs9 <= hs10)
        return;

    HasSpaceshipMem hs11, hs12;
    if (hs11 >= hs12)
        return;
}
)cpp";
  auto withArgs = [](StringRef lName, StringRef rName) {
    return cxxOperatorCallExpr(
        hasArgument(0, declRefExpr(to(varDecl(hasName(lName))))),
        hasArgument(1, declRefExpr(to(varDecl(hasName(rName))))));
  };
  {
    auto M = ifStmt(hasCondition(cxxOperatorCallExpr(
        hasOverloadedOperatorName("=="), withArgs("hs1", "hs2"))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M =
        unaryOperator(hasOperatorName("!"),
                      has(cxxOperatorCallExpr(hasOverloadedOperatorName("=="),
                                              withArgs("hs3", "hs4"))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M =
        unaryOperator(hasOperatorName("!"),
                      has(cxxOperatorCallExpr(hasOverloadedOperatorName("=="),
                                              withArgs("hs3", "hs4"))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = binaryOperator(
        hasOperatorName("<"),
        hasLHS(hasDescendant(cxxOperatorCallExpr(
            hasOverloadedOperatorName("<=>"), withArgs("hs5", "hs6")))),
        hasRHS(integerLiteral(equals(0))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = cxxRewrittenBinaryOperator(withDescendants("hs3", "hs4"));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = declRefExpr(to(varDecl(hasName("hs3"))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = cxxRewrittenBinaryOperator(has(
        unaryOperator(hasOperatorName("!"), withDescendants("hs3", "hs4"))));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    auto M = cxxRewrittenBinaryOperator(
        has(declRefExpr(to(varDecl(hasName("hs3"))))),
        has(declRefExpr(to(varDecl(hasName("hs4"))))));
    EXPECT_FALSE(
        matchesConditionally(Code, traverse(TK_AsIs, M), true, {"-std=c++20"}));
    EXPECT_TRUE(
        matchesConditionally(Code, traverse(TK_IgnoreUnlessSpelledInSource, M),
                             true, {"-std=c++20"}));
  }
  {
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName("!="), hasAnyOperatorName("<", "!="),
                     isComparisonOperator(),
                     hasLHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs3")))))),
                     hasRHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs4")))))),
                     hasEitherOperand(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs3")))))),
                     hasOperands(ignoringImplicit(
                                     declRefExpr(to(varDecl(hasName("hs3"))))),
                                 ignoringImplicit(declRefExpr(
                                     to(varDecl(hasName("hs4")))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_IgnoreUnlessSpelledInSource,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName("!="), hasAnyOperatorName("<", "!="),
                     isComparisonOperator(),
                     hasLHS(declRefExpr(to(varDecl(hasName("hs3"))))),
                     hasRHS(declRefExpr(to(varDecl(hasName("hs4"))))),
                     hasEitherOperand(declRefExpr(to(varDecl(hasName("hs3"))))),
                     hasOperands(declRefExpr(to(varDecl(hasName("hs3")))),
                                 declRefExpr(to(varDecl(hasName("hs4"))))))),
        true, {"-std=c++20"}));
  }
  {
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName("<"), hasAnyOperatorName("<", "!="),
                     isComparisonOperator(),
                     hasLHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs5")))))),
                     hasRHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs6")))))),
                     hasEitherOperand(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs5")))))),
                     hasOperands(ignoringImplicit(
                                     declRefExpr(to(varDecl(hasName("hs5"))))),
                                 ignoringImplicit(declRefExpr(
                                     to(varDecl(hasName("hs6")))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_IgnoreUnlessSpelledInSource,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName("<"), hasAnyOperatorName("<", "!="),
                     isComparisonOperator(),
                     hasLHS(declRefExpr(to(varDecl(hasName("hs5"))))),
                     hasRHS(declRefExpr(to(varDecl(hasName("hs6"))))),
                     hasEitherOperand(declRefExpr(to(varDecl(hasName("hs5"))))),
                     hasOperands(declRefExpr(to(varDecl(hasName("hs5")))),
                                 declRefExpr(to(varDecl(hasName("hs6"))))))),
        true, {"-std=c++20"}));
  }
  {
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName(">"), hasAnyOperatorName("<", ">"),
                     isComparisonOperator(),
                     hasLHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs7")))))),
                     hasRHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs8")))))),
                     hasEitherOperand(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs7")))))),
                     hasOperands(ignoringImplicit(
                                     declRefExpr(to(varDecl(hasName("hs7"))))),
                                 ignoringImplicit(declRefExpr(
                                     to(varDecl(hasName("hs8")))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_IgnoreUnlessSpelledInSource,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName(">"), hasAnyOperatorName("<", ">"),
                     isComparisonOperator(),
                     hasLHS(declRefExpr(to(varDecl(hasName("hs7"))))),
                     hasRHS(declRefExpr(to(varDecl(hasName("hs8"))))),
                     hasEitherOperand(declRefExpr(to(varDecl(hasName("hs7"))))),
                     hasOperands(declRefExpr(to(varDecl(hasName("hs7")))),
                                 declRefExpr(to(varDecl(hasName("hs8"))))))),
        true, {"-std=c++20"}));
  }
  {
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName("<="), hasAnyOperatorName("<", "<="),
                     isComparisonOperator(),
                     hasLHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs9")))))),
                     hasRHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs10")))))),
                     hasEitherOperand(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs9")))))),
                     hasOperands(ignoringImplicit(
                                     declRefExpr(to(varDecl(hasName("hs9"))))),
                                 ignoringImplicit(declRefExpr(
                                     to(varDecl(hasName("hs10")))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_IgnoreUnlessSpelledInSource,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName("<="), hasAnyOperatorName("<", "<="),
                     isComparisonOperator(),
                     hasLHS(declRefExpr(to(varDecl(hasName("hs9"))))),
                     hasRHS(declRefExpr(to(varDecl(hasName("hs10"))))),
                     hasEitherOperand(declRefExpr(to(varDecl(hasName("hs9"))))),
                     hasOperands(declRefExpr(to(varDecl(hasName("hs9")))),
                                 declRefExpr(to(varDecl(hasName("hs10"))))))),
        true, {"-std=c++20"}));
  }
  {
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs,
                 cxxRewrittenBinaryOperator(
                     hasOperatorName(">="), hasAnyOperatorName("<", ">="),
                     isComparisonOperator(),
                     hasLHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs11")))))),
                     hasRHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs12")))))),
                     hasEitherOperand(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("hs11")))))),
                     hasOperands(ignoringImplicit(
                                     declRefExpr(to(varDecl(hasName("hs11"))))),
                                 ignoringImplicit(declRefExpr(
                                     to(varDecl(hasName("hs12")))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(
            TK_IgnoreUnlessSpelledInSource,
            cxxRewrittenBinaryOperator(
                hasOperatorName(">="), hasAnyOperatorName("<", ">="),
                isComparisonOperator(),
                hasLHS(declRefExpr(to(varDecl(hasName("hs11"))))),
                hasRHS(declRefExpr(to(varDecl(hasName("hs12"))))),
                hasEitherOperand(declRefExpr(to(varDecl(hasName("hs11"))))),
                hasOperands(declRefExpr(to(varDecl(hasName("hs11")))),
                            declRefExpr(to(varDecl(hasName("hs12"))))))),
        true, {"-std=c++20"}));
  }

  Code = R"cpp(
struct S {};

struct HasOpEq
{
    bool operator==(const S& other) const
    {
        return true;
    }
};

struct HasOpEqMem {
  bool operator==(const HasOpEqMem&) const { return true; }
};

struct HasOpEqFree {
};
bool operator==(const HasOpEqFree&, const HasOpEqFree&) { return true; }

void binop()
{
    {
    HasOpEq s1;
    S s2;
    if (s1 != s2)
        return;
    }

    {
      int i1;
      int i2;
      if (i1 != i2)
          return;
    }

    {
      HasOpEqMem M1;
      HasOpEqMem M2;
      if (M1 == M2)
          return;
    }

    {
      HasOpEqFree F1;
      HasOpEqFree F2;
      if (F1 == F2)
          return;
    }
}
)cpp";
  {
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs,
                 binaryOperation(
                     hasOperatorName("!="), hasAnyOperatorName("<", "!="),
                     isComparisonOperator(),
                     hasLHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("s1")))))),
                     hasRHS(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("s2")))))),
                     hasEitherOperand(ignoringImplicit(
                         declRefExpr(to(varDecl(hasName("s2")))))),
                     hasOperands(ignoringImplicit(
                                     declRefExpr(to(varDecl(hasName("s1"))))),
                                 ignoringImplicit(declRefExpr(
                                     to(varDecl(hasName("s2")))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs, binaryOperation(hasOperatorName("!="),
                                          hasLHS(ignoringImplicit(declRefExpr(
                                              to(varDecl(hasName("i1")))))),
                                          hasRHS(ignoringImplicit(declRefExpr(
                                              to(varDecl(hasName("i2")))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs, binaryOperation(hasOperatorName("=="),
                                          hasLHS(ignoringImplicit(declRefExpr(
                                              to(varDecl(hasName("M1")))))),
                                          hasRHS(ignoringImplicit(declRefExpr(
                                              to(varDecl(hasName("M2")))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_AsIs, binaryOperation(hasOperatorName("=="),
                                          hasLHS(ignoringImplicit(declRefExpr(
                                              to(varDecl(hasName("F1")))))),
                                          hasRHS(ignoringImplicit(declRefExpr(
                                              to(varDecl(hasName("F2")))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(TK_IgnoreUnlessSpelledInSource,
                 binaryOperation(
                     hasOperatorName("!="), hasAnyOperatorName("<", "!="),
                     isComparisonOperator(),
                     hasLHS(declRefExpr(to(varDecl(hasName("s1"))))),
                     hasRHS(declRefExpr(to(varDecl(hasName("s2"))))),
                     hasEitherOperand(declRefExpr(to(varDecl(hasName("s2"))))),
                     hasOperands(declRefExpr(to(varDecl(hasName("s1")))),
                                 declRefExpr(to(varDecl(hasName("s2"))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(
            TK_IgnoreUnlessSpelledInSource,
            binaryOperation(hasOperatorName("!="),
                            hasLHS(declRefExpr(to(varDecl(hasName("i1"))))),
                            hasRHS(declRefExpr(to(varDecl(hasName("i2"))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(
            TK_IgnoreUnlessSpelledInSource,
            binaryOperation(hasOperatorName("=="),
                            hasLHS(declRefExpr(to(varDecl(hasName("M1"))))),
                            hasRHS(declRefExpr(to(varDecl(hasName("M2"))))))),
        true, {"-std=c++20"}));
    EXPECT_TRUE(matchesConditionally(
        Code,
        traverse(
            TK_IgnoreUnlessSpelledInSource,
            binaryOperation(hasOperatorName("=="),
                            hasLHS(declRefExpr(to(varDecl(hasName("F1"))))),
                            hasRHS(declRefExpr(to(varDecl(hasName("F2"))))))),
        true, {"-std=c++20"}));
  }
}

TEST(IgnoringImpCasts, PathologicalLambda) {

  // Test that deeply nested lambdas are not a performance penalty
  StringRef Code = R"cpp(
void f() {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
  [] {
    int i = 42;
    (void)i;
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
  }();
}
  )cpp";

  EXPECT_TRUE(matches(Code, integerLiteral(equals(42))));
  EXPECT_TRUE(matches(Code, functionDecl(hasDescendant(integerLiteral(equals(42))))));
}

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.
  EXPECT_TRUE(matches("char x = 0;",
                      varDecl(hasInitializer(ignoringImpCasts(
                        integerLiteral(equals(0)))))));
}

TEST(IgnoringImpCasts, DoesNotMatchIncorrectly) {
  // These tests verify that ignoringImpCasts does not match if the inner
  // matcher does not match.
  // Note that the first test creates an implicit const cast.
  EXPECT_TRUE(notMatches("int x; const int y = x;",
                         varDecl(hasInitializer(ignoringImpCasts(
                           unless(anything()))))));
  EXPECT_TRUE(notMatches("int x; int y = x;",
                         varDecl(hasInitializer(ignoringImpCasts(
                           unless(anything()))))));

  // These tests verify that ignoringImplictCasts does not look through explicit
  // casts or parentheses.
  EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
                         varDecl(hasInitializer(ignoringImpCasts(
                           integerLiteral())))));
  EXPECT_TRUE(notMatches(
      "int i = (0);",
      traverse(TK_AsIs,
               varDecl(hasInitializer(ignoringImpCasts(integerLiteral()))))));
  EXPECT_TRUE(notMatches("float i = (float)0;",
                         varDecl(hasInitializer(ignoringImpCasts(
                           integerLiteral())))));
  EXPECT_TRUE(notMatches("float i = float(0);",
                         varDecl(hasInitializer(ignoringImpCasts(
                           integerLiteral())))));
}

TEST(IgnoringImpCasts, MatchesWithoutImpCasts) {
  // This test verifies that expressions that do not have implicit casts
  // still match the inner matcher.
  EXPECT_TRUE(matches("int x = 0; int &y = x;",
                      varDecl(hasInitializer(ignoringImpCasts(
                        declRefExpr(to(varDecl(hasName("x")))))))));
}

TEST(IgnoringParenCasts, MatchesParenCasts) {
  // This test checks that ignoringParenCasts matches when parentheses and/or
  // casts are present and its inner matcher alone does not match.
  EXPECT_TRUE(matches("int x = (0);",
                      varDecl(hasInitializer(ignoringParenCasts(
                        integerLiteral(equals(0)))))));
  EXPECT_TRUE(matches("int x = (((((0)))));",
                      varDecl(hasInitializer(ignoringParenCasts(
                        integerLiteral(equals(0)))))));

  // This test creates an implict cast from int to char in addition to the
  // parentheses.
  EXPECT_TRUE(matches("char x = (0);",
                      varDecl(hasInitializer(ignoringParenCasts(
                        integerLiteral(equals(0)))))));

  EXPECT_TRUE(matches("char x = (char)0;",
                      varDecl(hasInitializer(ignoringParenCasts(
                        integerLiteral(equals(0)))))));
  EXPECT_TRUE(matches("char* p = static_cast<char*>(0);",
                      varDecl(hasInitializer(ignoringParenCasts(
                        integerLiteral(equals(0)))))));
}

TEST(IgnoringParenCasts, MatchesWithoutParenCasts) {
  // This test verifies that expressions that do not have any casts still match.
  EXPECT_TRUE(matches("int x = 0;",
                      varDecl(hasInitializer(ignoringParenCasts(
                        integerLiteral(equals(0)))))));
}

TEST(IgnoringParenCasts, DoesNotMatchIncorrectly) {
  // These tests verify that ignoringImpCasts does not match if the inner
  // matcher does not match.
  EXPECT_TRUE(notMatches("int x = ((0));",
                         varDecl(hasInitializer(ignoringParenCasts(
                           unless(anything()))))));

  // This test creates an implicit cast from int to char in addition to the
  // parentheses.
  EXPECT_TRUE(notMatches("char x = ((0));",
                         varDecl(hasInitializer(ignoringParenCasts(
                           unless(anything()))))));

  EXPECT_TRUE(notMatches("char *x = static_cast<char *>((0));",
                         varDecl(hasInitializer(ignoringParenCasts(
                           unless(anything()))))));
}

TEST(IgnoringParenAndImpCasts, MatchesParenImpCasts) {
  // This test checks that ignoringParenAndImpCasts matches when
  // parentheses and/or 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(ignoringParenImpCasts(
                        declRefExpr(to(varDecl(hasName("x")))))))));
  // This test creates an implicit cast from int to char.
  EXPECT_TRUE(matches("const char x = (0);",
                      varDecl(hasInitializer(ignoringParenImpCasts(
                        integerLiteral(equals(0)))))));
}

TEST(IgnoringParenAndImpCasts, MatchesWithoutParenImpCasts) {
  // This test verifies that expressions that do not have parentheses or
  // implicit casts still match.
  EXPECT_TRUE(matches("int x = 0; int &y = x;",
                      varDecl(hasInitializer(ignoringParenImpCasts(
                        declRefExpr(to(varDecl(hasName("x")))))))));
  EXPECT_TRUE(matches("int x = 0;",
                      varDecl(hasInitializer(ignoringParenImpCasts(
                        integerLiteral(equals(0)))))));
}

TEST(IgnoringParenAndImpCasts, DoesNotMatchIncorrectly) {
  // These tests verify that ignoringParenImpCasts does not match if
  // the inner matcher does not match.
  // This test creates an implicit cast.
  EXPECT_TRUE(notMatches("char c = ((3));",
                         varDecl(hasInitializer(ignoringParenImpCasts(
                           unless(anything()))))));
  // These tests verify that ignoringParenAndImplictCasts does not look
  // through explicit casts.
  EXPECT_TRUE(notMatches("float y = (float(0));",
                         varDecl(hasInitializer(ignoringParenImpCasts(
                           integerLiteral())))));
  EXPECT_TRUE(notMatches("float y = (float)0;",
                         varDecl(hasInitializer(ignoringParenImpCasts(
                           integerLiteral())))));
  EXPECT_TRUE(notMatches("char* p = static_cast<char*>(0);",
                         varDecl(hasInitializer(ignoringParenImpCasts(
                           integerLiteral())))));
}

TEST(HasSourceExpression, MatchesImplicitCasts) {
  EXPECT_TRUE(matches("class string {}; class URL { public: URL(string s); };"
                      "void r() {string a_string; URL url = a_string; }",
                      traverse(TK_AsIs, implicitCastExpr(hasSourceExpression(
                                            cxxConstructExpr())))));
}

TEST(HasSourceExpression, MatchesExplicitCasts) {
  EXPECT_TRUE(
      matches("float x = static_cast<float>(42);",
              traverse(TK_AsIs, explicitCastExpr(hasSourceExpression(
                                    hasDescendant(expr(integerLiteral())))))));
}

TEST(UsingDeclaration, MatchesSpecificTarget) {
  EXPECT_TRUE(matches("namespace f { int a; void b(); } using f::b;",
                      usingDecl(hasAnyUsingShadowDecl(
                        hasTargetDecl(functionDecl())))));
  EXPECT_TRUE(notMatches("namespace f { int a; void b(); } using f::a;",
                         usingDecl(hasAnyUsingShadowDecl(
                           hasTargetDecl(functionDecl())))));
}

TEST(UsingDeclaration, ThroughUsingDeclaration) {
  EXPECT_TRUE(matches(
    "namespace a { void f(); } using a::f; void g() { f(); }",
    declRefExpr(throughUsingDecl(anything()))));
  EXPECT_TRUE(notMatches(
    "namespace a { void f(); } using a::f; void g() { a::f(); }",
    declRefExpr(throughUsingDecl(anything()))));
}

TEST(SingleDecl, IsSingleDecl) {
  StatementMatcher SingleDeclStmt =
    declStmt(hasSingleDecl(varDecl(hasInitializer(anything()))));
  EXPECT_TRUE(matches("void f() {int a = 4;}", SingleDeclStmt));
  EXPECT_TRUE(notMatches("void f() {int a;}", SingleDeclStmt));
  EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
                         SingleDeclStmt));
}

TEST(DeclStmt, ContainsDeclaration) {
  DeclarationMatcher MatchesInit = varDecl(hasInitializer(anything()));

  EXPECT_TRUE(matches("void f() {int a = 4;}",
                      declStmt(containsDeclaration(0, MatchesInit))));
  EXPECT_TRUE(matches("void f() {int a = 4, b = 3;}",
                      declStmt(containsDeclaration(0, MatchesInit),
                               containsDeclaration(1, MatchesInit))));
  unsigned WrongIndex = 42;
  EXPECT_TRUE(notMatches("void f() {int a = 4, b = 3;}",
                         declStmt(containsDeclaration(WrongIndex,
                                                      MatchesInit))));
}

TEST(SwitchCase, MatchesEachCase) {
  EXPECT_TRUE(notMatches("void x() { switch(42); }",
                         switchStmt(forEachSwitchCase(caseStmt()))));
  EXPECT_TRUE(matches("void x() { switch(42) case 42:; }",
                      switchStmt(forEachSwitchCase(caseStmt()))));
  EXPECT_TRUE(matches("void x() { switch(42) { case 42:; } }",
                      switchStmt(forEachSwitchCase(caseStmt()))));
  EXPECT_TRUE(notMatches(
    "void x() { if (1) switch(42) { case 42: switch (42) { default:; } } }",
    ifStmt(has(switchStmt(forEachSwitchCase(defaultStmt()))))));
  EXPECT_TRUE(matches(
      "void x() { switch(42) { case 1+1: case 4:; } }",
      traverse(TK_AsIs, switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
                            constantExpr(has(integerLiteral())))))))));
  EXPECT_TRUE(notMatches(
      "void x() { switch(42) { case 1+1: case 2+2:; } }",
      traverse(TK_AsIs, switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
                            constantExpr(has(integerLiteral())))))))));
  EXPECT_TRUE(notMatches(
      "void x() { switch(42) { case 1 ... 2:; } }",
      traverse(TK_AsIs, switchStmt(forEachSwitchCase(caseStmt(hasCaseConstant(
                            constantExpr(has(integerLiteral())))))))));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void x() { switch (42) { case 1: case 2: case 3: default:; } }",
    switchStmt(forEachSwitchCase(caseStmt().bind("x"))),
    std::make_unique<VerifyIdIsBoundTo<CaseStmt>>("x", 3)));
}

TEST(Declaration, HasExplicitSpecifier) {

  EXPECT_TRUE(notMatches("void f();",
                         functionDecl(hasExplicitSpecifier(constantExpr())),
                         langCxx20OrLater()));
  EXPECT_TRUE(
      notMatches("template<bool b> struct S { explicit operator int(); };",
                 cxxConversionDecl(
                     hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
                 langCxx20OrLater()));
  EXPECT_TRUE(
      notMatches("template<bool b> struct S { explicit(b) operator int(); };",
                 cxxConversionDecl(
                     hasExplicitSpecifier(constantExpr(has(cxxBoolLiteral())))),
                 langCxx20OrLater()));
  EXPECT_TRUE(
      matches("struct S { explicit(true) operator int(); };",
              traverse(TK_AsIs, cxxConversionDecl(hasExplicitSpecifier(
                                    constantExpr(has(cxxBoolLiteral()))))),
              langCxx20OrLater()));
  EXPECT_TRUE(
      matches("struct S { explicit(false) operator int(); };",
              traverse(TK_AsIs, cxxConversionDecl(hasExplicitSpecifier(
                                    constantExpr(has(cxxBoolLiteral()))))),
              langCxx20OrLater()));
  EXPECT_TRUE(
      notMatches("template<bool b> struct S { explicit(b) S(int); };",
                 traverse(TK_AsIs, cxxConstructorDecl(hasExplicitSpecifier(
                                       constantExpr(has(cxxBoolLiteral()))))),
                 langCxx20OrLater()));
  EXPECT_TRUE(
      matches("struct S { explicit(true) S(int); };",
              traverse(TK_AsIs, cxxConstructorDecl(hasExplicitSpecifier(
                                    constantExpr(has(cxxBoolLiteral()))))),
              langCxx20OrLater()));
  EXPECT_TRUE(
      matches("struct S { explicit(false) S(int); };",
              traverse(TK_AsIs, cxxConstructorDecl(hasExplicitSpecifier(
                                    constantExpr(has(cxxBoolLiteral()))))),
              langCxx20OrLater()));
  EXPECT_TRUE(
      notMatches("template<typename T> struct S { S(int); };"
                 "template<bool b = true> explicit(b) S(int) -> S<int>;",
                 traverse(TK_AsIs, cxxDeductionGuideDecl(hasExplicitSpecifier(
                                       constantExpr(has(cxxBoolLiteral()))))),
                 langCxx20OrLater()));
  EXPECT_TRUE(
      matches("template<typename T> struct S { S(int); };"
              "explicit(true) S(int) -> S<int>;",
              traverse(TK_AsIs, cxxDeductionGuideDecl(hasExplicitSpecifier(
                                    constantExpr(has(cxxBoolLiteral()))))),
              langCxx20OrLater()));
  EXPECT_TRUE(
      matches("template<typename T> struct S { S(int); };"
              "explicit(false) S(int) -> S<int>;",
              traverse(TK_AsIs, cxxDeductionGuideDecl(hasExplicitSpecifier(
                                    constantExpr(has(cxxBoolLiteral()))))),
              langCxx20OrLater()));
}

TEST(ForEachConstructorInitializer, MatchesInitializers) {
  EXPECT_TRUE(matches(
    "struct X { X() : i(42), j(42) {} int i, j; };",
    cxxConstructorDecl(forEachConstructorInitializer(cxxCtorInitializer()))));
}

TEST(ForEachLambdaCapture, MatchesCaptures) {
  EXPECT_TRUE(matches(
      "int main() { int x, y; auto f = [x, y]() { return x + y; }; }",
      lambdaExpr(forEachLambdaCapture(lambdaCapture())), langCxx11OrLater()));
  auto matcher = lambdaExpr(forEachLambdaCapture(
      lambdaCapture(capturesVar(varDecl(hasType(isInteger())))).bind("LC")));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "int main() { int x, y; float z; auto f = [=]() { return x + y + z; }; }",
      matcher, std::make_unique<VerifyIdIsBoundTo<LambdaCapture>>("LC", 2)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "int main() { int x, y; float z; auto f = [x, y, z]() { return x + y + "
      "z; }; }",
      matcher, std::make_unique<VerifyIdIsBoundTo<LambdaCapture>>("LC", 2)));
}

TEST(ForEachLambdaCapture, IgnoreUnlessSpelledInSource) {
  auto matcher =
      traverse(TK_IgnoreUnlessSpelledInSource,
               lambdaExpr(forEachLambdaCapture(
                   lambdaCapture(capturesVar(varDecl(hasType(isInteger()))))
                       .bind("LC"))));
  EXPECT_TRUE(
      notMatches("int main() { int x, y; auto f = [=]() { return x + y; }; }",
                 matcher, langCxx11OrLater()));
  EXPECT_TRUE(
      notMatches("int main() { int x, y; auto f = [&]() { return x + y; }; }",
                 matcher, langCxx11OrLater()));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      R"cc(
      int main() {
        int x, y;
        float z;
        auto f = [=, &y]() { return x + y + z; };
      }
      )cc",
      matcher, std::make_unique<VerifyIdIsBoundTo<LambdaCapture>>("LC", 1)));
}

TEST(ForEachLambdaCapture, MatchImplicitCapturesOnly) {
  auto matcher =
      lambdaExpr(forEachLambdaCapture(lambdaCapture(isImplicit()).bind("LC")));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "int main() { int x, y, z; auto f = [=, &z]() { return x + y + z; }; }",
      matcher, std::make_unique<VerifyIdIsBoundTo<LambdaCapture>>("LC", 2)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "int main() { int x, y, z; auto f = [&, z]() { return x + y + z; }; }",
      matcher, std::make_unique<VerifyIdIsBoundTo<LambdaCapture>>("LC", 2)));
}

TEST(ForEachLambdaCapture, MatchExplicitCapturesOnly) {
  auto matcher = lambdaExpr(
      forEachLambdaCapture(lambdaCapture(unless(isImplicit())).bind("LC")));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "int main() { int x, y, z; auto f = [=, &z]() { return x + y + z; }; }",
      matcher, std::make_unique<VerifyIdIsBoundTo<LambdaCapture>>("LC", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      "int main() { int x, y, z; auto f = [&, z]() { return x + y + z; }; }",
      matcher, std::make_unique<VerifyIdIsBoundTo<LambdaCapture>>("LC", 1)));
}

TEST(HasConditionVariableStatement, DoesNotMatchCondition) {
  EXPECT_TRUE(notMatches(
    "void x() { if(true) {} }",
    ifStmt(hasConditionVariableStatement(declStmt()))));
  EXPECT_TRUE(notMatches(
    "void x() { int x; if((x = 42)) {} }",
    ifStmt(hasConditionVariableStatement(declStmt()))));
}

TEST(HasConditionVariableStatement, MatchesConditionVariables) {
  EXPECT_TRUE(matches(
    "void x() { if(int* a = 0) {} }",
    ifStmt(hasConditionVariableStatement(declStmt()))));
}

TEST(ForEach, BindsOneNode) {
  EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; };",
                                       recordDecl(hasName("C"), forEach(fieldDecl(hasName("x")).bind("x"))),
                                       std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("x", 1)));
}

TEST(ForEach, BindsMultipleNodes) {
  EXPECT_TRUE(matchAndVerifyResultTrue("class C { int x; int y; int z; };",
                                       recordDecl(hasName("C"), forEach(fieldDecl().bind("f"))),
                                       std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 3)));
}

TEST(ForEach, BindsRecursiveCombinations) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class C { class D { int x; int y; }; class E { int y; int z; }; };",
    recordDecl(hasName("C"),
               forEach(recordDecl(forEach(fieldDecl().bind("f"))))),
    std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 4)));
}

TEST(ForEach, DoesNotIgnoreImplicit) {
  StringRef Code = R"cpp(
void foo()
{
    int i = 0;
    int b = 4;
    i < b;
}
)cpp";
  EXPECT_TRUE(matchAndVerifyResultFalse(
      Code, binaryOperator(forEach(declRefExpr().bind("dre"))),
      std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("dre", 0)));

  EXPECT_TRUE(matchAndVerifyResultTrue(
      Code,
      binaryOperator(forEach(
          implicitCastExpr(hasSourceExpression(declRefExpr().bind("dre"))))),
      std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("dre", 2)));

  EXPECT_TRUE(matchAndVerifyResultTrue(
      Code,
      binaryOperator(
          forEach(expr(ignoringImplicit(declRefExpr().bind("dre"))))),
      std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("dre", 2)));

  EXPECT_TRUE(matchAndVerifyResultTrue(
      Code,
      traverse(TK_IgnoreUnlessSpelledInSource,
               binaryOperator(forEach(declRefExpr().bind("dre")))),
      std::make_unique<VerifyIdIsBoundTo<DeclRefExpr>>("dre", 2)));
}

TEST(ForEachDescendant, BindsOneNode) {
  EXPECT_TRUE(matchAndVerifyResultTrue("class C { class D { int x; }; };",
                                       recordDecl(hasName("C"),
                                                  forEachDescendant(fieldDecl(hasName("x")).bind("x"))),
                                       std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("x", 1)));
}

TEST(ForEachDescendant, NestedForEachDescendant) {
  DeclarationMatcher m = recordDecl(
    isDefinition(), decl().bind("x"), hasName("C"));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A { class B { class C {}; }; };",
    recordDecl(hasName("A"), anyOf(m, forEachDescendant(m))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", "C")));

  // Check that a partial match of 'm' that binds 'x' in the
  // first part of anyOf(m, anything()) will not overwrite the
  // binding created by the earlier binding in the hasDescendant.
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A { class B { class C {}; }; };",
    recordDecl(hasName("A"), allOf(hasDescendant(m), anyOf(m, anything()))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", "C")));
}

TEST(ForEachDescendant, BindsMultipleNodes) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class C { class D { int x; int y; }; "
      "          class E { class F { int y; int z; }; }; };",
    recordDecl(hasName("C"), forEachDescendant(fieldDecl().bind("f"))),
    std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 4)));
}

TEST(ForEachDescendant, BindsRecursiveCombinations) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class C { class D { "
      "          class E { class F { class G { int y; int z; }; }; }; }; };",
    recordDecl(hasName("C"), forEachDescendant(recordDecl(
      forEachDescendant(fieldDecl().bind("f"))))),
    std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("f", 8)));
}

TEST(ForEachDescendant, BindsCombinations) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void f() { if(true) {} if (true) {} while (true) {} if (true) {} while "
      "(true) {} }",
    compoundStmt(forEachDescendant(ifStmt().bind("if")),
                 forEachDescendant(whileStmt().bind("while"))),
    std::make_unique<VerifyIdIsBoundTo<IfStmt>>("if", 6)));
}

TEST(Has, DoesNotDeleteBindings) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class X { int a; };", recordDecl(decl().bind("x"), has(fieldDecl())),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
}

TEST(TemplateArgumentLoc, Matches) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
      R"cpp(
        template <typename A, int B, template <typename> class C> class X {};
        class A {};
        const int B = 42;
        template <typename> class C {};
        X<A, B, C> x;
      )cpp",
      templateArgumentLoc().bind("x"),
      std::make_unique<VerifyIdIsBoundTo<TemplateArgumentLoc>>("x", 3)));
}

TEST(LoopingMatchers, DoNotOverwritePreviousMatchResultOnFailure) {
  // Those matchers cover all the cases where an inner matcher is called
  // and there is not a 1:1 relationship between the match of the outer
  // matcher and the match of the inner matcher.
  // The pattern to look for is:
  //   ... return InnerMatcher.matches(...); ...
  // In which case no special handling is needed.
  //
  // On the other hand, if there are multiple alternative matches
  // (for example forEach*) or matches might be discarded (for example has*)
  // the implementation must make sure that the discarded matches do not
  // affect the bindings.
  // When new such matchers are added, add a test here that:
  // - matches a simple node, and binds it as the first thing in the matcher:
  //     recordDecl(decl().bind("x"), hasName("X")))
  // - uses the matcher under test afterwards in a way that not the first
  //   alternative is matched; for anyOf, that means the first branch
  //   would need to return false; for hasAncestor, it means that not
  //   the direct parent matches the inner matcher.

  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class X { int y; };",
    recordDecl(
      recordDecl().bind("x"), hasName("::X"),
      anyOf(forEachDescendant(recordDecl(hasName("Y"))), anything())),
    std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class X {};", recordDecl(recordDecl().bind("x"), hasName("::X"),
                              anyOf(unless(anything()), anything())),
    std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "template<typename T1, typename T2> class X {}; X<float, int> x;",
    classTemplateSpecializationDecl(
      decl().bind("x"),
      hasAnyTemplateArgument(refersToType(asString("int")))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class X { void f(); void g(); };",
    cxxRecordDecl(decl().bind("x"), hasMethod(hasName("g"))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class X { X() : a(1), b(2) {} double a; int b; };",
    recordDecl(decl().bind("x"),
               has(cxxConstructorDecl(
                 hasAnyConstructorInitializer(forField(hasName("b")))))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void x(int, int) { x(0, 42); }",
    callExpr(expr().bind("x"), hasAnyArgument(integerLiteral(equals(42)))),
    std::make_unique<VerifyIdIsBoundTo<Expr>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void x(int, int y) {}",
    functionDecl(decl().bind("x"), hasAnyParameter(hasName("y"))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void x() { return; if (true) {} }",
    functionDecl(decl().bind("x"),
                 has(compoundStmt(hasAnySubstatement(ifStmt())))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "namespace X { void b(int); void b(); }"
      "using X::b;",
    usingDecl(decl().bind("x"), hasAnyUsingShadowDecl(hasTargetDecl(
      functionDecl(parameterCountIs(1))))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A{}; class B{}; class C : B, A {};",
    cxxRecordDecl(decl().bind("x"), isDerivedFrom("::A")),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A{}; typedef A B; typedef A C; typedef A D;"
      "class E : A {};",
    cxxRecordDecl(decl().bind("x"), isDerivedFrom("C")),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A { class B { void f() {} }; };",
    functionDecl(decl().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "template <typename T> struct A { struct B {"
      "  void f() { if(true) {} }"
      "}; };"
      "void t() { A<int>::B b; b.f(); }",
    ifStmt(stmt().bind("x"), hasAncestor(recordDecl(hasName("::A")))),
    std::make_unique<VerifyIdIsBoundTo<Stmt>>("x", 2)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A {};",
    recordDecl(hasName("::A"), decl().bind("x"), unless(hasName("fooble"))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A { A() : s(), i(42) {} const char *s; int i; };",
    cxxConstructorDecl(hasName("::A::A"), decl().bind("x"),
                       forEachConstructorInitializer(forField(hasName("i")))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("x", 1)));
}

TEST(ForEachDescendant, BindsCorrectNodes) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class C { void f(); int i; };",
    recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
    std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("decl", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class C { void f() {} int i; };",
    recordDecl(hasName("C"), forEachDescendant(decl().bind("decl"))),
    std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("decl", 1)));
}

TEST(FindAll, BindsNodeOnMatch) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A {};",
    recordDecl(hasName("::A"), findAll(recordDecl(hasName("::A")).bind("v"))),
    std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("v", 1)));
}

TEST(FindAll, BindsDescendantNodeOnMatch) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A { int a; int b; };",
    recordDecl(hasName("::A"), findAll(fieldDecl().bind("v"))),
    std::make_unique<VerifyIdIsBoundTo<FieldDecl>>("v", 2)));
}

TEST(FindAll, BindsNodeAndDescendantNodesOnOneMatch) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A { int a; int b; };",
    recordDecl(hasName("::A"),
               findAll(decl(anyOf(recordDecl(hasName("::A")).bind("v"),
                                  fieldDecl().bind("v"))))),
    std::make_unique<VerifyIdIsBoundTo<Decl>>("v", 3)));

  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class A { class B {}; class C {}; };",
    recordDecl(hasName("::A"), findAll(recordDecl(isDefinition()).bind("v"))),
    std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("v", 3)));
}

TEST(HasAncenstor, MatchesDeclarationAncestors) {
  EXPECT_TRUE(matches(
    "class A { class B { class C {}; }; };",
    recordDecl(hasName("C"), hasAncestor(recordDecl(hasName("A"))))));
}

TEST(HasAncenstor, FailsIfNoAncestorMatches) {
  EXPECT_TRUE(notMatches(
    "class A { class B { class C {}; }; };",
    recordDecl(hasName("C"), hasAncestor(recordDecl(hasName("X"))))));
}

TEST(HasAncestor, MatchesDeclarationsThatGetVisitedLater) {
  EXPECT_TRUE(matches(
    "class A { class B { void f() { C c; } class C {}; }; };",
    varDecl(hasName("c"), hasType(recordDecl(hasName("C"),
                                             hasAncestor(recordDecl(hasName("A"))))))));
}

TEST(HasAncenstor, MatchesStatementAncestors) {
  EXPECT_TRUE(matches(
    "void f() { if (true) { while (false) { 42; } } }",
    integerLiteral(equals(42), hasAncestor(ifStmt()))));
}

TEST(HasAncestor, DrillsThroughDifferentHierarchies) {
  EXPECT_TRUE(matches(
    "void f() { if (true) { int x = 42; } }",
    integerLiteral(equals(42), hasAncestor(functionDecl(hasName("f"))))));
}

TEST(HasAncestor, BindsRecursiveCombinations) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class C { class D { class E { class F { int y; }; }; }; };",
    fieldDecl(hasAncestor(recordDecl(hasAncestor(recordDecl().bind("r"))))),
    std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("r", 1)));
}

TEST(HasAncestor, BindsCombinationsWithHasDescendant) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class C { class D { class E { class F { int y; }; }; }; };",
    fieldDecl(hasAncestor(
      decl(
        hasDescendant(recordDecl(isDefinition(),
                                 hasAncestor(recordDecl())))
      ).bind("d")
    )),
    std::make_unique<VerifyIdIsBoundTo<CXXRecordDecl>>("d", "E")));
}

TEST(HasAncestor, MatchesClosestAncestor) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "template <typename T> struct C {"
      "  void f(int) {"
      "    struct I { void g(T) { int x; } } i; i.g(42);"
      "  }"
      "};"
      "template struct C<int>;",
    varDecl(hasName("x"),
            hasAncestor(functionDecl(hasParameter(
              0, varDecl(hasType(asString("int"))))).bind("f"))).bind("v"),
    std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("f", "g", 2)));
}

TEST(HasAncestor, MatchesInTemplateInstantiations) {
  EXPECT_TRUE(matches(
    "template <typename T> struct A { struct B { struct C { T t; }; }; }; "
      "A<int>::B::C a;",
    fieldDecl(hasType(asString("int")),
              hasAncestor(recordDecl(hasName("A"))))));
}

TEST(HasAncestor, MatchesInImplicitCode) {
  EXPECT_TRUE(matches(
    "struct X {}; struct A { A() {} X x; };",
    cxxConstructorDecl(
      hasAnyConstructorInitializer(withInitializer(expr(
        hasAncestor(recordDecl(hasName("A")))))))));
}

TEST(HasParent, MatchesOnlyParent) {
  EXPECT_TRUE(matches(
    "void f() { if (true) { int x = 42; } }",
    compoundStmt(hasParent(ifStmt()))));
  EXPECT_TRUE(notMatches(
    "void f() { for (;;) { int x = 42; } }",
    compoundStmt(hasParent(ifStmt()))));
  EXPECT_TRUE(notMatches(
    "void f() { if (true) for (;;) { int x = 42; } }",
    compoundStmt(hasParent(ifStmt()))));
}

TEST(MatcherMemoize, HasParentDiffersFromHas) {
  // Test introduced after detecting a bug in memoization
  constexpr auto code = "void f() { throw 1; }";
  EXPECT_TRUE(notMatches(
    code,
    cxxThrowExpr(hasParent(expr()))));
  EXPECT_TRUE(matches(
    code,
    cxxThrowExpr(has(expr()))));
  EXPECT_TRUE(matches(
    code,
    cxxThrowExpr(anyOf(hasParent(expr()), has(expr())))));
}

TEST(MatcherMemoize, HasDiffersFromHasDescendant) {
  // Test introduced after detecting a bug in memoization
  constexpr auto code = "void f() { throw 1+1; }";
  EXPECT_TRUE(notMatches(
    code,
    cxxThrowExpr(has(integerLiteral()))));
  EXPECT_TRUE(matches(
    code,
    cxxThrowExpr(hasDescendant(integerLiteral()))));
  EXPECT_TRUE(
      notMatches(code, cxxThrowExpr(allOf(hasDescendant(integerLiteral()),
                                          has(integerLiteral())))));
}
TEST(HasAncestor, MatchesAllAncestors) {
  EXPECT_TRUE(matches(
    "template <typename T> struct C { static void f() { 42; } };"
      "void t() { C<int>::f(); }",
    integerLiteral(
      equals(42),
      allOf(
        hasAncestor(cxxRecordDecl(isTemplateInstantiation())),
        hasAncestor(cxxRecordDecl(unless(isTemplateInstantiation())))))));
}

TEST(HasAncestor, ImplicitArrayCopyCtorDeclRefExpr) {
  EXPECT_TRUE(matches("struct MyClass {\n"
                        "  int c[1];\n"
                        "  static MyClass Create() { return MyClass(); }\n"
                        "};",
                      declRefExpr(to(decl(hasAncestor(decl()))))));
}

TEST(HasAncestor, AnonymousUnionMemberExpr) {
  EXPECT_TRUE(matches("int F() {\n"
                        "  union { int i; };\n"
                        "  return i;\n"
                        "}\n",
                      memberExpr(member(hasAncestor(decl())))));
  EXPECT_TRUE(matches("void f() {\n"
                        "  struct {\n"
                        "    struct { int a; int b; };\n"
                        "  } s;\n"
                        "  s.a = 4;\n"
                        "}\n",
                      memberExpr(member(hasAncestor(decl())))));
  EXPECT_TRUE(matches("void f() {\n"
                        "  struct {\n"
                        "    struct { int a; int b; };\n"
                        "  } s;\n"
                        "  s.a = 4;\n"
                        "}\n",
                      declRefExpr(to(decl(hasAncestor(decl()))))));
}
TEST(HasAncestor, NonParmDependentTemplateParmVarDeclRefExpr) {
  EXPECT_TRUE(matches("struct PartitionAllocator {\n"
                        "  template<typename T>\n"
                        "  static int quantizedSize(int count) {\n"
                        "    return count;\n"
                        "  }\n"
                        "  void f() { quantizedSize<int>(10); }\n"
                        "};",
                      declRefExpr(to(decl(hasAncestor(decl()))))));
}

TEST(HasAncestor, AddressOfExplicitSpecializationFunction) {
  EXPECT_TRUE(matches("template <class T> void f();\n"
                        "template <> void f<int>();\n"
                        "void (*get_f())() { return f<int>; }\n",
                      declRefExpr(to(decl(hasAncestor(decl()))))));
}

TEST(HasParent, MatchesAllParents) {
  EXPECT_TRUE(matches(
    "template <typename T> struct C { static void f() { 42; } };"
      "void t() { C<int>::f(); }",
    integerLiteral(
      equals(42),
      hasParent(compoundStmt(hasParent(functionDecl(
        hasParent(cxxRecordDecl(isTemplateInstantiation())))))))));
  EXPECT_TRUE(
    matches("template <typename T> struct C { static void f() { 42; } };"
              "void t() { C<int>::f(); }",
            integerLiteral(
              equals(42),
              hasParent(compoundStmt(hasParent(functionDecl(hasParent(
                cxxRecordDecl(unless(isTemplateInstantiation()))))))))));
  EXPECT_TRUE(matches(
    "template <typename T> struct C { static void f() { 42; } };"
      "void t() { C<int>::f(); }",
    integerLiteral(equals(42),
                   hasParent(compoundStmt(
                     allOf(hasParent(functionDecl(hasParent(
                       cxxRecordDecl(isTemplateInstantiation())))),
                           hasParent(functionDecl(hasParent(cxxRecordDecl(
                             unless(isTemplateInstantiation())))))))))));
  EXPECT_TRUE(
    notMatches("template <typename T> struct C { static void f() {} };"
                 "void t() { C<int>::f(); }",
               compoundStmt(hasParent(recordDecl()))));
}

TEST(HasParent, NoDuplicateParents) {
  class HasDuplicateParents : public BoundNodesCallback {
  public:
    bool run(const BoundNodes *Nodes) override { return false; }
    bool run(const BoundNodes *Nodes, ASTContext *Context) override {
      const Stmt *Node = Nodes->getNodeAs<Stmt>("node");
      std::set<const void *> Parents;
      for (const auto &Parent : Context->getParents(*Node)) {
        if (!Parents.insert(Parent.getMemoizationData()).second) {
          return true;
        }
      }
      return false;
    }
  };
  EXPECT_FALSE(matchAndVerifyResultTrue(
    "template <typename T> int Foo() { return 1 + 2; }\n"
      "int x = Foo<int>() + Foo<unsigned>();",
    stmt().bind("node"), std::make_unique<HasDuplicateParents>()));
}

TEST(TypeMatching, PointeeTypes) {
  EXPECT_TRUE(matches("int b; int &a = b;",
                      referenceType(pointee(builtinType()))));
  EXPECT_TRUE(matches("int *a;", pointerType(pointee(builtinType()))));

  EXPECT_TRUE(matches("int *a;",
                      loc(pointerType(pointee(builtinType())))));

  EXPECT_TRUE(matches(
    "int const *A;",
    pointerType(pointee(isConstQualified(), builtinType()))));
  EXPECT_TRUE(notMatches(
    "int *A;",
    pointerType(pointee(isConstQualified(), builtinType()))));
}

TEST(ElaboratedTypeNarrowing, hasQualifier) {
  EXPECT_TRUE(matches(
    "namespace N {"
      "  namespace M {"
      "    class D {};"
      "  }"
      "}"
      "N::M::D d;",
    elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N")))))));
  EXPECT_TRUE(notMatches(
    "namespace M {"
      "  class D {};"
      "}"
      "M::D d;",
    elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N")))))));
  EXPECT_TRUE(notMatches(
    "struct D {"
      "} d;",
    elaboratedType(hasQualifier(nestedNameSpecifier()))));
}

TEST(ElaboratedTypeNarrowing, namesType) {
  EXPECT_TRUE(matches(
    "namespace N {"
      "  namespace M {"
      "    class D {};"
      "  }"
      "}"
      "N::M::D d;",
    elaboratedType(elaboratedType(namesType(recordType(
      hasDeclaration(namedDecl(hasName("D")))))))));
  EXPECT_TRUE(notMatches(
    "namespace M {"
      "  class D {};"
      "}"
      "M::D d;",
    elaboratedType(elaboratedType(namesType(typedefType())))));
}

TEST(NNS, BindsNestedNameSpecifiers) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "namespace ns { struct E { struct B {}; }; } ns::E::B b;",
    nestedNameSpecifier(specifiesType(asString("struct ns::E"))).bind("nns"),
    std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>(
      "nns", "ns::struct E::")));
}

TEST(NNS, BindsNestedNameSpecifierLocs) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "namespace ns { struct B {}; } ns::B b;",
    loc(nestedNameSpecifier()).bind("loc"),
    std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("loc", 1)));
}

TEST(NNS, DescendantsOfNestedNameSpecifiers) {
  StringRef Fragment =
      "namespace a { struct A { struct B { struct C {}; }; }; };"
      "void f() { a::A::B::C c; }";
  EXPECT_TRUE(matches(
    Fragment,
    nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
                        hasDescendant(nestedNameSpecifier(
                          specifiesNamespace(hasName("a")))))));
  EXPECT_TRUE(notMatches(
    Fragment,
    nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
                        has(nestedNameSpecifier(
                          specifiesNamespace(hasName("a")))))));
  EXPECT_TRUE(matches(
    Fragment,
    nestedNameSpecifier(specifiesType(asString("struct a::A")),
                        has(nestedNameSpecifier(
                          specifiesNamespace(hasName("a")))))));

  // Not really useful because a NestedNameSpecifier can af at most one child,
  // but to complete the interface.
  EXPECT_TRUE(matchAndVerifyResultTrue(
    Fragment,
    nestedNameSpecifier(specifiesType(asString("struct a::A::B")),
                        forEach(nestedNameSpecifier().bind("x"))),
    std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("x", 1)));
}

TEST(NNS, NestedNameSpecifiersAsDescendants) {
  StringRef Fragment =
      "namespace a { struct A { struct B { struct C {}; }; }; };"
      "void f() { a::A::B::C c; }";
  EXPECT_TRUE(matches(
    Fragment,
    decl(hasDescendant(nestedNameSpecifier(specifiesType(
      asString("struct a::A")))))));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    Fragment,
    functionDecl(hasName("f"),
                 forEachDescendant(nestedNameSpecifier().bind("x"))),
    // Nested names: a, a::A and a::A::B.
    std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifier>>("x", 3)));
}

TEST(NNSLoc, DescendantsOfNestedNameSpecifierLocs) {
  StringRef Fragment =
      "namespace a { struct A { struct B { struct C {}; }; }; };"
      "void f() { a::A::B::C c; }";
  EXPECT_TRUE(matches(
    Fragment,
    nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
                           hasDescendant(loc(nestedNameSpecifier(
                             specifiesNamespace(hasName("a"))))))));
  EXPECT_TRUE(notMatches(
    Fragment,
    nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
                           has(loc(nestedNameSpecifier(
                             specifiesNamespace(hasName("a"))))))));
  EXPECT_TRUE(matches(
    Fragment,
    nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A"))),
                           has(loc(nestedNameSpecifier(
                             specifiesNamespace(hasName("a"))))))));

  EXPECT_TRUE(matchAndVerifyResultTrue(
    Fragment,
    nestedNameSpecifierLoc(loc(specifiesType(asString("struct a::A::B"))),
                           forEach(nestedNameSpecifierLoc().bind("x"))),
    std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("x", 1)));
}

TEST(NNSLoc, NestedNameSpecifierLocsAsDescendants) {
  StringRef Fragment =
      "namespace a { struct A { struct B { struct C {}; }; }; };"
      "void f() { a::A::B::C c; }";
  EXPECT_TRUE(matches(
    Fragment,
    decl(hasDescendant(loc(nestedNameSpecifier(specifiesType(
      asString("struct a::A"))))))));
  EXPECT_TRUE(matchAndVerifyResultTrue(
    Fragment,
    functionDecl(hasName("f"),
                 forEachDescendant(nestedNameSpecifierLoc().bind("x"))),
    // Nested names: a, a::A and a::A::B.
    std::make_unique<VerifyIdIsBoundTo<NestedNameSpecifierLoc>>("x", 3)));
}

TEST(Attr, AttrsAsDescendants) {
  StringRef Fragment = "namespace a { struct [[clang::warn_unused_result]] "
                       "F{}; [[noreturn]] void foo(); }";
  EXPECT_TRUE(matches(Fragment, namespaceDecl(hasDescendant(attr()))));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      Fragment,
      namespaceDecl(hasName("a"),
                    forEachDescendant(attr(unless(isImplicit())).bind("x"))),
      std::make_unique<VerifyIdIsBoundTo<Attr>>("x", 2)));
}

TEST(Attr, ParentsOfAttrs) {
  StringRef Fragment =
      "namespace a { struct [[clang::warn_unused_result]] F{}; }";
  EXPECT_TRUE(matches(Fragment, attr(hasAncestor(namespaceDecl()))));
}

template <typename T> class VerifyMatchOnNode : public BoundNodesCallback {
public:
  VerifyMatchOnNode(StringRef Id, const internal::Matcher<T> &InnerMatcher,
                    StringRef InnerId)
    : Id(Id), InnerMatcher(InnerMatcher), InnerId(InnerId) {
  }

  bool run(const BoundNodes *Nodes) override { return false; }

  bool run(const BoundNodes *Nodes, ASTContext *Context) override {
    const T *Node = Nodes->getNodeAs<T>(Id);
    return selectFirst<T>(InnerId, match(InnerMatcher, *Node, *Context)) !=
      nullptr;
  }
private:
  std::string Id;
  internal::Matcher<T> InnerMatcher;
  std::string InnerId;
};

TEST(MatchFinder, CanMatchDeclarationsRecursively) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
    std::make_unique<VerifyMatchOnNode<Decl>>(
      "X", decl(hasDescendant(recordDecl(hasName("X::Y")).bind("Y"))),
      "Y")));
  EXPECT_TRUE(matchAndVerifyResultFalse(
    "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
    std::make_unique<VerifyMatchOnNode<Decl>>(
      "X", decl(hasDescendant(recordDecl(hasName("X::Z")).bind("Z"))),
      "Z")));
}

TEST(MatchFinder, CanMatchStatementsRecursively) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
    std::make_unique<VerifyMatchOnNode<Stmt>>(
      "if", stmt(hasDescendant(forStmt().bind("for"))), "for")));
  EXPECT_TRUE(matchAndVerifyResultFalse(
    "void f() { if (1) { for (;;) { } } }", ifStmt().bind("if"),
    std::make_unique<VerifyMatchOnNode<Stmt>>(
      "if", stmt(hasDescendant(declStmt().bind("decl"))), "decl")));
}

TEST(MatchFinder, CanMatchSingleNodesRecursively) {
  EXPECT_TRUE(matchAndVerifyResultTrue(
    "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
    std::make_unique<VerifyMatchOnNode<Decl>>(
      "X", recordDecl(has(recordDecl(hasName("X::Y")).bind("Y"))), "Y")));
  EXPECT_TRUE(matchAndVerifyResultFalse(
    "class X { class Y {}; };", recordDecl(hasName("::X")).bind("X"),
    std::make_unique<VerifyMatchOnNode<Decl>>(
      "X", recordDecl(has(recordDecl(hasName("X::Z")).bind("Z"))), "Z")));
}

TEST(StatementMatcher, HasReturnValue) {
  StatementMatcher RetVal = returnStmt(hasReturnValue(binaryOperator()));
  EXPECT_TRUE(matches("int F() { int a, b; return a + b; }", RetVal));
  EXPECT_FALSE(matches("int F() { int a; return a; }", RetVal));
  EXPECT_FALSE(matches("void F() { return; }", RetVal));
}

TEST(StatementMatcher, ForFunction) {
  StringRef CppString1 = "struct PosVec {"
                         "  PosVec& operator=(const PosVec&) {"
                         "    auto x = [] { return 1; };"
                         "    return *this;"
                         "  }"
                         "};";
  StringRef CppString2 = "void F() {"
                         "  struct S {"
                         "    void F2() {"
                         "       return;"
                         "    }"
                         "  };"
                         "}";
  EXPECT_TRUE(
    matches(
      CppString1,
      returnStmt(forFunction(hasName("operator=")),
                 has(unaryOperator(hasOperatorName("*"))))));
  EXPECT_TRUE(
    notMatches(
      CppString1,
      returnStmt(forFunction(hasName("operator=")),
                 has(integerLiteral()))));
  EXPECT_TRUE(
    matches(
      CppString1,
      returnStmt(forFunction(hasName("operator()")),
                 has(integerLiteral()))));
  EXPECT_TRUE(matches(CppString2, returnStmt(forFunction(hasName("F2")))));
  EXPECT_TRUE(notMatches(CppString2, returnStmt(forFunction(hasName("F")))));
}

TEST(StatementMatcher, ForCallable) {
  // These tests are copied over from the forFunction() test above.
  StringRef CppString1 = "struct PosVec {"
                         "  PosVec& operator=(const PosVec&) {"
                         "    auto x = [] { return 1; };"
                         "    return *this;"
                         "  }"
                         "};";
  StringRef CppString2 = "void F() {"
                         "  struct S {"
                         "    void F2() {"
                         "       return;"
                         "    }"
                         "  };"
                         "}";

  EXPECT_TRUE(
    matches(
      CppString1,
      returnStmt(forCallable(functionDecl(hasName("operator="))),
                 has(unaryOperator(hasOperatorName("*"))))));
  EXPECT_TRUE(
    notMatches(
      CppString1,
      returnStmt(forCallable(functionDecl(hasName("operator="))),
                 has(integerLiteral()))));
  EXPECT_TRUE(
    matches(
      CppString1,
      returnStmt(forCallable(functionDecl(hasName("operator()"))),
                 has(integerLiteral()))));
  EXPECT_TRUE(matches(CppString2,
                      returnStmt(forCallable(functionDecl(hasName("F2"))))));
  EXPECT_TRUE(notMatches(CppString2,
                         returnStmt(forCallable(functionDecl(hasName("F"))))));

  // These tests are specific to forCallable().
  StringRef ObjCString1 = "@interface I"
                          "-(void) foo;"
                          "@end"
                          "@implementation I"
                          "-(void) foo {"
                          "  void (^block)() = ^{ 0x2b | ~0x2b; };"
                          "}"
                          "@end";

  EXPECT_TRUE(
    matchesObjC(
      ObjCString1,
      binaryOperator(forCallable(blockDecl()))));

  EXPECT_TRUE(
    notMatchesObjC(
      ObjCString1,
      binaryOperator(forCallable(objcMethodDecl()))));

  StringRef ObjCString2 = "@interface I"
                          "-(void) foo;"
                          "@end"
                          "@implementation I"
                          "-(void) foo {"
                          "  0x2b | ~0x2b;"
                          "  void (^block)() = ^{};"
                          "}"
                          "@end";

  EXPECT_TRUE(
    matchesObjC(
      ObjCString2,
      binaryOperator(forCallable(objcMethodDecl()))));

  EXPECT_TRUE(
    notMatchesObjC(
      ObjCString2,
      binaryOperator(forCallable(blockDecl()))));
}

TEST(Matcher, ForEachOverriden) {
  const auto ForEachOverriddenInClass = [](const char *ClassName) {
    return cxxMethodDecl(ofClass(hasName(ClassName)), isVirtual(),
                         forEachOverridden(cxxMethodDecl().bind("overridden")))
        .bind("override");
  };
  static const char Code1[] = "class A { virtual void f(); };"
                              "class B : public A { void f(); };"
                              "class C : public B { void f(); };";
  // C::f overrides A::f.
  EXPECT_TRUE(matchAndVerifyResultTrue(
      Code1, ForEachOverriddenInClass("C"),
      std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      Code1, ForEachOverriddenInClass("C"),
      std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
                                                          1)));
  // B::f overrides A::f.
  EXPECT_TRUE(matchAndVerifyResultTrue(
      Code1, ForEachOverriddenInClass("B"),
      std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 1)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      Code1, ForEachOverriddenInClass("B"),
      std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
                                                          1)));
  // A::f overrides nothing.
  EXPECT_TRUE(notMatches(Code1, ForEachOverriddenInClass("A")));

  static const char Code2[] =
      "class A1 { virtual void f(); };"
      "class A2 { virtual void f(); };"
      "class B : public A1, public A2 { void f(); };";
  // B::f overrides A1::f and A2::f. This produces two matches.
  EXPECT_TRUE(matchAndVerifyResultTrue(
      Code2, ForEachOverriddenInClass("B"),
      std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("override", "f", 2)));
  EXPECT_TRUE(matchAndVerifyResultTrue(
      Code2, ForEachOverriddenInClass("B"),
      std::make_unique<VerifyIdIsBoundTo<CXXMethodDecl>>("overridden", "f",
                                                          2)));
  // A1::f overrides nothing.
  EXPECT_TRUE(notMatches(Code2, ForEachOverriddenInClass("A1")));
}

TEST(Matcher, HasAnyDeclaration) {
  StringRef Fragment = "void foo(int p1);"
                       "void foo(int *p2);"
                       "void bar(int p3);"
                       "template <typename T> void baz(T t) { foo(t); }";

  EXPECT_TRUE(
      matches(Fragment, unresolvedLookupExpr(hasAnyDeclaration(functionDecl(
                            hasParameter(0, parmVarDecl(hasName("p1"))))))));
  EXPECT_TRUE(
      matches(Fragment, unresolvedLookupExpr(hasAnyDeclaration(functionDecl(
                            hasParameter(0, parmVarDecl(hasName("p2"))))))));
  EXPECT_TRUE(
      notMatches(Fragment, unresolvedLookupExpr(hasAnyDeclaration(functionDecl(
                               hasParameter(0, parmVarDecl(hasName("p3"))))))));
  EXPECT_TRUE(notMatches(Fragment, unresolvedLookupExpr(hasAnyDeclaration(
                                       functionDecl(hasName("bar"))))));
}

TEST(SubstTemplateTypeParmType, HasReplacementType) {
  StringRef Fragment = "template<typename T>"
                       "double F(T t);"
                       "int i;"
                       "double j = F(i);";
  EXPECT_TRUE(matches(Fragment, substTemplateTypeParmType(hasReplacementType(
                                    qualType(asString("int"))))));
  EXPECT_TRUE(notMatches(Fragment, substTemplateTypeParmType(hasReplacementType(
                                       qualType(asString("double"))))));
  EXPECT_TRUE(
      notMatches("template<int N>"
                 "double F();"
                 "double j = F<5>();",
                 substTemplateTypeParmType(hasReplacementType(qualType()))));
}

TEST(ClassTemplateSpecializationDecl, HasSpecializedTemplate) {
  auto Matcher = classTemplateSpecializationDecl(
      hasSpecializedTemplate(classTemplateDecl()));
  EXPECT_TRUE(
      matches("template<typename T> class A {}; typedef A<int> B;", Matcher));
  EXPECT_TRUE(notMatches("template<typename T> class A {};", Matcher));
}

TEST(CXXNewExpr, Array) {
  StatementMatcher NewArray = cxxNewExpr(isArray());

  EXPECT_TRUE(matches("void foo() { int *Ptr = new int[10]; }", NewArray));
  EXPECT_TRUE(notMatches("void foo() { int *Ptr = new int; }", NewArray));

  StatementMatcher NewArraySize10 =
      cxxNewExpr(hasArraySize(integerLiteral(equals(10))));
  EXPECT_TRUE(
      matches("void foo() { int *Ptr = new int[10]; }", NewArraySize10));
  EXPECT_TRUE(
      notMatches("void foo() { int *Ptr = new int[20]; }", NewArraySize10));
}

TEST(CXXNewExpr, PlacementArgs) {
  StatementMatcher IsPlacementNew = cxxNewExpr(hasAnyPlacementArg(anything()));

  EXPECT_TRUE(matches(R"(
    void* operator new(decltype(sizeof(void*)), void*);
    int *foo(void* Storage) {
      return new (Storage) int;
    })",
                      IsPlacementNew));

  EXPECT_TRUE(matches(R"(
    void* operator new(decltype(sizeof(void*)), void*, unsigned);
    int *foo(void* Storage) {
      return new (Storage, 16) int;
    })",
                      cxxNewExpr(hasPlacementArg(
                          1, ignoringImpCasts(integerLiteral(equals(16)))))));

  EXPECT_TRUE(notMatches(R"(
    void* operator new(decltype(sizeof(void*)), void*);
    int *foo(void* Storage) {
      return new int;
    })",
                         IsPlacementNew));
}

TEST(HasUnqualifiedLoc, BindsToConstIntVarDecl) {
  EXPECT_TRUE(matches(
      "const int x = 0;",
      varDecl(hasName("x"), hasTypeLoc(qualifiedTypeLoc(
                                hasUnqualifiedLoc(loc(asString("int"))))))));
}

TEST(HasUnqualifiedLoc, BindsToVolatileIntVarDecl) {
  EXPECT_TRUE(matches(
      "volatile int x = 0;",
      varDecl(hasName("x"), hasTypeLoc(qualifiedTypeLoc(
                                hasUnqualifiedLoc(loc(asString("int"))))))));
}

TEST(HasUnqualifiedLoc, BindsToConstVolatileIntVarDecl) {
  EXPECT_TRUE(matches(
      "const volatile int x = 0;",
      varDecl(hasName("x"), hasTypeLoc(qualifiedTypeLoc(
                                hasUnqualifiedLoc(loc(asString("int"))))))));
}

TEST(HasUnqualifiedLoc, BindsToConstPointerVarDecl) {
  auto matcher = varDecl(
      hasName("x"),
      hasTypeLoc(qualifiedTypeLoc(hasUnqualifiedLoc(pointerTypeLoc()))));
  EXPECT_TRUE(matches("int* const x = 0;", matcher));
  EXPECT_TRUE(notMatches("int const x = 0;", matcher));
}

TEST(HasUnqualifiedLoc, BindsToPointerToConstVolatileIntVarDecl) {
  EXPECT_TRUE(
      matches("const volatile int* x = 0;",
              varDecl(hasName("x"),
                      hasTypeLoc(pointerTypeLoc(hasPointeeLoc(qualifiedTypeLoc(
                          hasUnqualifiedLoc(loc(asString("int"))))))))));
}

TEST(HasUnqualifiedLoc, BindsToConstIntFunctionDecl) {
  EXPECT_TRUE(
      matches("const int f() { return 5; }",
              functionDecl(hasName("f"),
                           hasReturnTypeLoc(qualifiedTypeLoc(
                               hasUnqualifiedLoc(loc(asString("int"))))))));
}

TEST(HasUnqualifiedLoc, FloatBindsToConstFloatVarDecl) {
  EXPECT_TRUE(matches(
      "const float x = 0;",
      varDecl(hasName("x"), hasTypeLoc(qualifiedTypeLoc(
                                hasUnqualifiedLoc(loc(asString("float"))))))));
}

TEST(HasUnqualifiedLoc, FloatDoesNotBindToIntVarDecl) {
  EXPECT_TRUE(notMatches(
      "int x = 0;",
      varDecl(hasName("x"), hasTypeLoc(qualifiedTypeLoc(
                                hasUnqualifiedLoc(loc(asString("float"))))))));
}

TEST(HasUnqualifiedLoc, FloatDoesNotBindToConstIntVarDecl) {
  EXPECT_TRUE(notMatches(
      "const int x = 0;",
      varDecl(hasName("x"), hasTypeLoc(qualifiedTypeLoc(
                                hasUnqualifiedLoc(loc(asString("float"))))))));
}

TEST(HasReturnTypeLoc, BindsToIntReturnTypeLoc) {
  EXPECT_TRUE(matches(
      "int f() { return 5; }",
      functionDecl(hasName("f"), hasReturnTypeLoc(loc(asString("int"))))));
}

TEST(HasReturnTypeLoc, BindsToFloatReturnTypeLoc) {
  EXPECT_TRUE(matches(
      "float f() { return 5.0; }",
      functionDecl(hasName("f"), hasReturnTypeLoc(loc(asString("float"))))));
}

TEST(HasReturnTypeLoc, BindsToVoidReturnTypeLoc) {
  EXPECT_TRUE(matches(
      "void f() {}",
      functionDecl(hasName("f"), hasReturnTypeLoc(loc(asString("void"))))));
}

TEST(HasReturnTypeLoc, FloatDoesNotBindToIntReturnTypeLoc) {
  EXPECT_TRUE(notMatches(
      "int f() { return 5; }",
      functionDecl(hasName("f"), hasReturnTypeLoc(loc(asString("float"))))));
}

TEST(HasReturnTypeLoc, IntDoesNotBindToFloatReturnTypeLoc) {
  EXPECT_TRUE(notMatches(
      "float f() { return 5.0; }",
      functionDecl(hasName("f"), hasReturnTypeLoc(loc(asString("int"))))));
}

TEST(HasPointeeLoc, BindsToAnyPointeeTypeLoc) {
  auto matcher = varDecl(hasName("x"),
                         hasTypeLoc(pointerTypeLoc(hasPointeeLoc(typeLoc()))));
  EXPECT_TRUE(matches("int* x;", matcher));
  EXPECT_TRUE(matches("float* x;", matcher));
  EXPECT_TRUE(matches("char* x;", matcher));
  EXPECT_TRUE(matches("void* x;", matcher));
}

TEST(HasPointeeLoc, DoesNotBindToTypeLocWithoutPointee) {
  auto matcher = varDecl(hasName("x"),
                         hasTypeLoc(pointerTypeLoc(hasPointeeLoc(typeLoc()))));
  EXPECT_TRUE(notMatches("int x;", matcher));
  EXPECT_TRUE(notMatches("float x;", matcher));
  EXPECT_TRUE(notMatches("char x;", matcher));
}

TEST(HasPointeeLoc, BindsToTypeLocPointingToInt) {
  EXPECT_TRUE(
      matches("int* x;", pointerTypeLoc(hasPointeeLoc(loc(asString("int"))))));
}

TEST(HasPointeeLoc, BindsToTypeLocPointingToIntPointer) {
  EXPECT_TRUE(matches("int** x;",
                      pointerTypeLoc(hasPointeeLoc(loc(asString("int *"))))));
}

TEST(HasPointeeLoc, BindsToTypeLocPointingToTypeLocPointingToInt) {
  EXPECT_TRUE(matches("int** x;", pointerTypeLoc(hasPointeeLoc(pointerTypeLoc(
                                      hasPointeeLoc(loc(asString("int"))))))));
}

TEST(HasPointeeLoc, BindsToTypeLocPointingToFloat) {
  EXPECT_TRUE(matches("float* x;",
                      pointerTypeLoc(hasPointeeLoc(loc(asString("float"))))));
}

TEST(HasPointeeLoc, IntPointeeDoesNotBindToTypeLocPointingToFloat) {
  EXPECT_TRUE(notMatches("float* x;",
                         pointerTypeLoc(hasPointeeLoc(loc(asString("int"))))));
}

TEST(HasPointeeLoc, FloatPointeeDoesNotBindToTypeLocPointingToInt) {
  EXPECT_TRUE(notMatches(
      "int* x;", pointerTypeLoc(hasPointeeLoc(loc(asString("float"))))));
}

TEST(HasReferentLoc, BindsToAnyReferentTypeLoc) {
  auto matcher = varDecl(
      hasName("r"), hasTypeLoc(referenceTypeLoc(hasReferentLoc(typeLoc()))));
  EXPECT_TRUE(matches("int rr = 3; int& r = rr;", matcher));
  EXPECT_TRUE(matches("int rr = 3; auto& r = rr;", matcher));
  EXPECT_TRUE(matches("int rr = 3; const int& r = rr;", matcher));
  EXPECT_TRUE(matches("float rr = 3.0; float& r = rr;", matcher));
  EXPECT_TRUE(matches("char rr = 'a'; char& r = rr;", matcher));
}

TEST(HasReferentLoc, DoesNotBindToTypeLocWithoutReferent) {
  auto matcher = varDecl(
      hasName("r"), hasTypeLoc(referenceTypeLoc(hasReferentLoc(typeLoc()))));
  EXPECT_TRUE(notMatches("int r;", matcher));
  EXPECT_TRUE(notMatches("int r = 3;", matcher));
  EXPECT_TRUE(notMatches("const int r = 3;", matcher));
  EXPECT_TRUE(notMatches("int* r;", matcher));
  EXPECT_TRUE(notMatches("float r;", matcher));
  EXPECT_TRUE(notMatches("char r;", matcher));
}

TEST(HasReferentLoc, BindsToAnyRvalueReference) {
  auto matcher = varDecl(
      hasName("r"), hasTypeLoc(referenceTypeLoc(hasReferentLoc(typeLoc()))));
  EXPECT_TRUE(matches("int&& r = 3;", matcher));
  EXPECT_TRUE(matches("auto&& r = 3;", matcher));
  EXPECT_TRUE(matches("float&& r = 3.0;", matcher));
}

TEST(HasReferentLoc, BindsToIntReferenceTypeLoc) {
  EXPECT_TRUE(matches("int rr = 3; int& r = rr;",
                      referenceTypeLoc(hasReferentLoc(loc(asString("int"))))));
}

TEST(HasReferentLoc, BindsToIntRvalueReferenceTypeLoc) {
  EXPECT_TRUE(matches("int&& r = 3;",
                      referenceTypeLoc(hasReferentLoc(loc(asString("int"))))));
}

TEST(HasReferentLoc, BindsToFloatReferenceTypeLoc) {
  EXPECT_TRUE(
      matches("float rr = 3.0; float& r = rr;",
              referenceTypeLoc(hasReferentLoc(loc(asString("float"))))));
}

TEST(HasReferentLoc, BindsToParameterWithIntReferenceTypeLoc) {
  EXPECT_TRUE(matches(
      "int f(int& r) { return r; }",
      parmVarDecl(hasName("r"), hasTypeLoc(referenceTypeLoc(
                                    hasReferentLoc(loc(asString("int"))))))));
}

TEST(HasReferentLoc, IntReferenceDoesNotBindToFloatReferenceTypeLoc) {
  EXPECT_TRUE(
      notMatches("float rr = 3.0; float& r = rr;",
                 referenceTypeLoc(hasReferentLoc(loc(asString("int"))))));
}

TEST(HasReferentLoc, FloatReferenceDoesNotBindToIntReferenceTypeLoc) {
  EXPECT_TRUE(
      notMatches("int rr = 3; int& r = rr;",
                 referenceTypeLoc(hasReferentLoc(loc(asString("float"))))));
}

TEST(HasReferentLoc, DoesNotBindToParameterWithoutIntReferenceTypeLoc) {
  EXPECT_TRUE(notMatches(
      "int f(int r) { return r; }",
      parmVarDecl(hasName("r"), hasTypeLoc(referenceTypeLoc(
                                    hasReferentLoc(loc(asString("int"))))))));
}

TEST(HasAnyTemplateArgumentLoc, BindsToSpecializationWithIntArgument) {
  EXPECT_TRUE(
      matches("template<typename T> class A {}; A<int> a;",
              varDecl(hasName("a"), hasTypeLoc(templateSpecializationTypeLoc(
                                        hasAnyTemplateArgumentLoc(hasTypeLoc(
                                            loc(asString("int")))))))));
}

TEST(HasAnyTemplateArgumentLoc, BindsToSpecializationWithDoubleArgument) {
  EXPECT_TRUE(
      matches("template<typename T> class A {}; A<double> a;",
              varDecl(hasName("a"), hasTypeLoc(templateSpecializationTypeLoc(
                                        hasAnyTemplateArgumentLoc(hasTypeLoc(
                                            loc(asString("double")))))))));
}

TEST(HasAnyTemplateArgumentLoc, BindsToExplicitSpecializationWithIntArgument) {
  EXPECT_TRUE(matches(
      "template<typename T> class A {}; template<> class A<int> {};",
      classTemplateSpecializationDecl(
          hasName("A"),
          hasTypeLoc(templateSpecializationTypeLoc(
              hasAnyTemplateArgumentLoc(hasTypeLoc(loc(asString("int")))))))));
}

TEST(HasAnyTemplateArgumentLoc,
     BindsToExplicitSpecializationWithDoubleArgument) {
  EXPECT_TRUE(matches(
      "template<typename T> class A {}; template<> class A<double> {};",
      classTemplateSpecializationDecl(
          hasName("A"),
          hasTypeLoc(templateSpecializationTypeLoc(hasAnyTemplateArgumentLoc(
              hasTypeLoc(loc(asString("double")))))))));
}

TEST(HasAnyTemplateArgumentLoc, BindsToSpecializationWithMultipleArguments) {
  auto code = R"(
  template<typename T, typename U> class A {};
  template<> class A<double, int> {};
  )";
  EXPECT_TRUE(
      matches(code, classTemplateSpecializationDecl(
                        hasName("A"), hasTypeLoc(templateSpecializationTypeLoc(
                                          hasAnyTemplateArgumentLoc(hasTypeLoc(
                                              loc(asString("double")))))))));
  EXPECT_TRUE(matches(
      code,
      classTemplateSpecializationDecl(
          hasName("A"),
          hasTypeLoc(templateSpecializationTypeLoc(
              hasAnyTemplateArgumentLoc(hasTypeLoc(loc(asString("int")))))))));
}

TEST(HasAnyTemplateArgumentLoc, DoesNotBindToSpecializationWithIntArgument) {
  EXPECT_TRUE(notMatches(
      "template<typename T> class A {}; A<int> a;",
      classTemplateSpecializationDecl(
          hasName("A"),
          hasTypeLoc(templateSpecializationTypeLoc(hasAnyTemplateArgumentLoc(
              hasTypeLoc(loc(asString("double")))))))));
}

TEST(HasAnyTemplateArgumentLoc,
     DoesNotBindToExplicitSpecializationWithIntArgument) {
  EXPECT_TRUE(notMatches(
      "template<typename T> class A {}; template<> class A<int> {};",
      classTemplateSpecializationDecl(
          hasName("A"),
          hasTypeLoc(templateSpecializationTypeLoc(hasAnyTemplateArgumentLoc(
              hasTypeLoc(loc(asString("double")))))))));
}

TEST(HasTemplateArgumentLoc, BindsToSpecializationWithIntArgument) {
  EXPECT_TRUE(matches(
      "template<typename T> class A {}; A<int> a;",
      varDecl(hasName("a"),
              hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
                  0, hasTypeLoc(loc(asString("int")))))))));
}

TEST(HasTemplateArgumentLoc, BindsToSpecializationWithDoubleArgument) {
  EXPECT_TRUE(matches(
      "template<typename T> class A {}; A<double> a;",
      varDecl(hasName("a"),
              hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
                  0, hasTypeLoc(loc(asString("double")))))))));
}

TEST(HasTemplateArgumentLoc, BindsToExplicitSpecializationWithIntArgument) {
  EXPECT_TRUE(matches(
      "template<typename T> class A {}; template<> class A<int> {};",
      classTemplateSpecializationDecl(
          hasName("A"),
          hasTypeLoc(templateSpecializationTypeLoc(
              hasTemplateArgumentLoc(0, hasTypeLoc(loc(asString("int")))))))));
}

TEST(HasTemplateArgumentLoc, BindsToExplicitSpecializationWithDoubleArgument) {
  EXPECT_TRUE(matches(
      "template<typename T> class A {}; template<> class A<double> {};",
      classTemplateSpecializationDecl(
          hasName("A"),
          hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
              0, hasTypeLoc(loc(asString("double")))))))));
}

TEST(HasTemplateArgumentLoc, BindsToSpecializationWithMultipleArguments) {
  auto code = R"(
  template<typename T, typename U> class A {};
  template<> class A<double, int> {};
  )";
  EXPECT_TRUE(matches(
      code, classTemplateSpecializationDecl(
                hasName("A"),
                hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
                    0, hasTypeLoc(loc(asString("double")))))))));
  EXPECT_TRUE(matches(
      code, classTemplateSpecializationDecl(
                hasName("A"),
                hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
                    1, hasTypeLoc(loc(asString("int")))))))));
}

TEST(HasTemplateArgumentLoc, DoesNotBindToSpecializationWithIntArgument) {
  EXPECT_TRUE(notMatches(
      "template<typename T> class A {}; A<int> a;",
      classTemplateSpecializationDecl(
          hasName("A"),
          hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
              0, hasTypeLoc(loc(asString("double")))))))));
}

TEST(HasTemplateArgumentLoc,
     DoesNotBindToExplicitSpecializationWithIntArgument) {
  EXPECT_TRUE(notMatches(
      "template<typename T> class A {}; template<> class A<int> {};",
      classTemplateSpecializationDecl(
          hasName("A"),
          hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
              0, hasTypeLoc(loc(asString("double")))))))));
}

TEST(HasTemplateArgumentLoc,
     DoesNotBindToSpecializationWithMisplacedArguments) {
  auto code = R"(
  template<typename T, typename U> class A {};
  template<> class A<double, int> {};
  )";
  EXPECT_TRUE(notMatches(
      code, classTemplateSpecializationDecl(
                hasName("A"),
                hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
                    1, hasTypeLoc(loc(asString("double")))))))));
  EXPECT_TRUE(notMatches(
      code, classTemplateSpecializationDecl(
                hasName("A"),
                hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
                    0, hasTypeLoc(loc(asString("int")))))))));
}

TEST(HasTemplateArgumentLoc, DoesNotBindWithBadIndex) {
  auto code = R"(
  template<typename T, typename U> class A {};
  template<> class A<double, int> {};
  )";
  EXPECT_TRUE(notMatches(
      code, classTemplateSpecializationDecl(
                hasName("A"),
                hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
                    -1, hasTypeLoc(loc(asString("double")))))))));
  EXPECT_TRUE(notMatches(
      code, classTemplateSpecializationDecl(
                hasName("A"),
                hasTypeLoc(templateSpecializationTypeLoc(hasTemplateArgumentLoc(
                    100, hasTypeLoc(loc(asString("int")))))))));
}

TEST(HasTemplateArgumentLoc, BindsToDeclRefExprWithIntArgument) {
  EXPECT_TRUE(matches(R"(
      template<typename T> T f(T t) { return t; }
      int g() { int i = f<int>(3); return i; }
      )",
                      declRefExpr(to(functionDecl(hasName("f"))),
                                  hasTemplateArgumentLoc(
                                      0, hasTypeLoc(loc(asString("int")))))));
}

TEST(HasTemplateArgumentLoc, BindsToDeclRefExprWithDoubleArgument) {
  EXPECT_TRUE(matches(
      R"(
      template<typename T> T f(T t) { return t; }
      double g() { double i = f<double>(3.0); return i; }
      )",
      declRefExpr(
          to(functionDecl(hasName("f"))),
          hasTemplateArgumentLoc(0, hasTypeLoc(loc(asString("double")))))));
}

TEST(HasTemplateArgumentLoc, DoesNotBindToDeclRefExprWithDoubleArgument) {
  EXPECT_TRUE(notMatches(
      R"(
      template<typename T> T f(T t) { return t; }
      double g() { double i = f<double>(3.0); return i; }
      )",
      declRefExpr(
          to(functionDecl(hasName("f"))),
          hasTemplateArgumentLoc(0, hasTypeLoc(loc(asString("int")))))));
}

TEST(HasNamedTypeLoc, BindsToElaboratedObjectDeclaration) {
  EXPECT_TRUE(matches(
      R"(
      template <typename T>
      class C {};
      class C<int> c;
      )",
      varDecl(hasName("c"),
              hasTypeLoc(elaboratedTypeLoc(
                  hasNamedTypeLoc(templateSpecializationTypeLoc(
                      hasAnyTemplateArgumentLoc(templateArgumentLoc()))))))));
}

TEST(HasNamedTypeLoc, DoesNotBindToNonElaboratedObjectDeclaration) {
  EXPECT_TRUE(notMatches(
      R"(
      template <typename T>
      class C {};
      C<int> c;
      )",
      varDecl(hasName("c"),
              hasTypeLoc(elaboratedTypeLoc(
                  hasNamedTypeLoc(templateSpecializationTypeLoc(
                      hasAnyTemplateArgumentLoc(templateArgumentLoc()))))))));
}

} // namespace ast_matchers
} // namespace clang