//===- unittest/Introspection/IntrospectionTest.cpp ----------*- C++ -*---===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Tests for AST location API introspection.
//
//===----------------------------------------------------------------------===//

#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Tooling/NodeIntrospection.h"
#include "clang/Tooling/Tooling.h"
#include "gmock/gmock-matchers.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

using namespace clang;
using namespace clang::ast_matchers;
using namespace clang::tooling;

using ::testing::Pair;
using ::testing::UnorderedElementsAre;

template<typename T, typename MapType>
std::map<std::string, T>
FormatExpected(const MapType &Accessors) {
  std::map<std::string, T> Result;
  llvm::transform(llvm::make_filter_range(Accessors,
                                          [](const auto &Accessor) {
                                            return Accessor.first.isValid();
                                          }),
                  std::inserter(Result, Result.end()),
                  [](const auto &Accessor) {
                    return std::make_pair(LocationCallFormatterCpp::format(
                                              *Accessor.second.get()),
                                          Accessor.first);
                  });
  return Result;
}

#define STRING_LOCATION_PAIR(INSTANCE, LOC) Pair(#LOC, INSTANCE->LOC)

/**
  A test formatter for a hypothetical language which needs
  neither casts nor '->'.
*/
class LocationCallFormatterSimple {
public:
  static void print(const LocationCall &Call, llvm::raw_ostream &OS) {
    if (Call.isCast()) {
      if (const LocationCall *On = Call.on())
        print(*On, OS);
      return;
    }
    if (const LocationCall *On = Call.on()) {
      print(*On, OS);
      OS << '.';
    }
    OS << Call.name() << "()";
  }

  static std::string format(const LocationCall &Call) {
    std::string Result;
    llvm::raw_string_ostream OS(Result);
    print(Call, OS);
    OS.flush();
    return Result;
  }
};

TEST(Introspection, SourceLocations_CallContainer) {
  SourceLocationMap slm;
  SharedLocationCall Prefix;
  slm.insert(std::make_pair(
      SourceLocation(),
      llvm::makeIntrusiveRefCnt<LocationCall>(Prefix, "getSourceRange")));
  EXPECT_EQ(slm.size(), 1u);

  auto callTypeLoc =
      llvm::makeIntrusiveRefCnt<LocationCall>(Prefix, "getTypeLoc");
  slm.insert(std::make_pair(
      SourceLocation(),
      llvm::makeIntrusiveRefCnt<LocationCall>(callTypeLoc, "getSourceRange")));
  EXPECT_EQ(slm.size(), 2u);
}

TEST(Introspection, SourceLocations_CallChainFormatting) {
  SharedLocationCall Prefix;
  auto chainedCall = llvm::makeIntrusiveRefCnt<LocationCall>(
      llvm::makeIntrusiveRefCnt<LocationCall>(Prefix, "getTypeLoc"),
      "getSourceRange");
  EXPECT_EQ(LocationCallFormatterCpp::format(*chainedCall),
            "getTypeLoc().getSourceRange()");
}

TEST(Introspection, SourceLocations_Formatter) {
  SharedLocationCall Prefix;
  auto chainedCall = llvm::makeIntrusiveRefCnt<LocationCall>(
      llvm::makeIntrusiveRefCnt<LocationCall>(
          llvm::makeIntrusiveRefCnt<LocationCall>(
              llvm::makeIntrusiveRefCnt<LocationCall>(
                  Prefix, "getTypeSourceInfo", LocationCall::ReturnsPointer),
              "getTypeLoc"),
          "getAs<clang::TypeSpecTypeLoc>", LocationCall::IsCast),
      "getNameLoc");

  EXPECT_EQ("getTypeSourceInfo()->getTypeLoc().getAs<clang::TypeSpecTypeLoc>()."
            "getNameLoc()",
            LocationCallFormatterCpp::format(*chainedCall));
  EXPECT_EQ("getTypeSourceInfo().getTypeLoc().getNameLoc()",
            LocationCallFormatterSimple::format(*chainedCall));
}

TEST(Introspection, SourceLocations_Stmt) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST = buildASTFromCode("void foo() {} void bar() { foo(); }", "foo.cpp",
                              std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(
          callExpr(callee(functionDecl(hasName("foo")))).bind("fooCall"))),
      TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  auto *FooCall = BoundNodes[0].getNodeAs<CallExpr>("fooCall");

  auto Result = NodeIntrospection::GetLocations(FooCall);

  auto ExpectedLocations =
    FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(
      ExpectedLocations,
      UnorderedElementsAre(STRING_LOCATION_PAIR(FooCall, getBeginLoc()),
                           STRING_LOCATION_PAIR(FooCall, getEndLoc()),
                           STRING_LOCATION_PAIR(FooCall, getExprLoc()),
                           STRING_LOCATION_PAIR(FooCall, getRParenLoc())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                  FooCall, getSourceRange())));
}

TEST(Introspection, SourceLocations_Decl) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
namespace ns1 {
namespace ns2 {
template <typename T, typename U> struct Foo {};
template <typename T, typename U> struct Bar {
  struct Nested {
    template <typename A, typename B>
    Foo<A, B> method(int i, bool b) const noexcept(true);
  };
};
} // namespace ns2
} // namespace ns1

template <typename T, typename U>
template <typename A, typename B>
ns1::ns2::Foo<A, B> ns1::ns2::Bar<T, U>::Nested::method(int i, bool b) const
    noexcept(true) {}
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(
          cxxMethodDecl(hasName("method"), isDefinition()).bind("method"))),
      TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *MethodDecl = BoundNodes[0].getNodeAs<CXXMethodDecl>("method");

  auto Result = NodeIntrospection::GetLocations(MethodDecl);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(
                  STRING_LOCATION_PAIR(MethodDecl, getBeginLoc()),
                  STRING_LOCATION_PAIR(MethodDecl, getBodyRBrace()),
                  STRING_LOCATION_PAIR(MethodDecl, getInnerLocStart()),
                  STRING_LOCATION_PAIR(MethodDecl, getLocation()),
                  STRING_LOCATION_PAIR(MethodDecl, getOuterLocStart()),
                  STRING_LOCATION_PAIR(MethodDecl, getTypeSpecEndLoc()),
                  STRING_LOCATION_PAIR(MethodDecl, getTypeSpecStartLoc()),
                  STRING_LOCATION_PAIR(MethodDecl, getEndLoc())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(
      ExpectedRanges,
      UnorderedElementsAre(
          STRING_LOCATION_PAIR(MethodDecl, getExceptionSpecSourceRange()),
          STRING_LOCATION_PAIR(MethodDecl, getParametersSourceRange()),
          STRING_LOCATION_PAIR(MethodDecl, getReturnTypeSourceRange()),
          STRING_LOCATION_PAIR(MethodDecl, getSourceRange())));
}

TEST(Introspection, SourceLocations_NNS) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
namespace ns
{
  struct A {
  void foo();
};
}
void ns::A::foo() {}
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(nestedNameSpecifierLoc().bind("nns"))), TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *NNS = BoundNodes[0].getNodeAs<NestedNameSpecifierLoc>("nns");

  auto Result = NodeIntrospection::GetLocations(NNS);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(
      ExpectedLocations,
      UnorderedElementsAre(STRING_LOCATION_PAIR(NNS, getBeginLoc()),
                           STRING_LOCATION_PAIR(NNS, getEndLoc()),
                           STRING_LOCATION_PAIR(NNS, getLocalBeginLoc()),
                           STRING_LOCATION_PAIR(NNS, getLocalEndLoc())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(
      ExpectedRanges,
      UnorderedElementsAre(STRING_LOCATION_PAIR(NNS, getLocalSourceRange()),
                           STRING_LOCATION_PAIR(NNS, getSourceRange())));
}

TEST(Introspection, SourceLocations_TA_Type) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
template<typename T>
  struct A {
  void foo();
};

void foo()
{
  A<int> a;
}
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(templateArgumentLoc().bind("ta"))), TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *TA = BoundNodes[0].getNodeAs<TemplateArgumentLoc>("ta");

  auto Result = NodeIntrospection::GetLocations(TA);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getLocation())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getSourceRange())));
}

TEST(Introspection, SourceLocations_TA_Decl) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
template<void(*Ty)()>
void test2() {}
void doNothing() {}
void test() {
    test2<doNothing>();
}
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(templateArgumentLoc().bind("ta"))), TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *TA = BoundNodes[0].getNodeAs<TemplateArgumentLoc>("ta");

  auto Result = NodeIntrospection::GetLocations(TA);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getLocation())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getSourceRange())));
}

TEST(Introspection, SourceLocations_TA_Nullptr) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
template<void(*Ty)()>
void test2() {}
void doNothing() {}
void test() {
    test2<nullptr>();
}
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(templateArgumentLoc().bind("ta"))), TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *TA = BoundNodes[0].getNodeAs<TemplateArgumentLoc>("ta");

  auto Result = NodeIntrospection::GetLocations(TA);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getLocation())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getSourceRange())));
}

TEST(Introspection, SourceLocations_TA_Integral) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
template<int>
void test2() {}
void test() {
    test2<42>();
}
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(templateArgumentLoc().bind("ta"))), TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *TA = BoundNodes[0].getNodeAs<TemplateArgumentLoc>("ta");

  auto Result = NodeIntrospection::GetLocations(TA);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getLocation())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getSourceRange())));
}

TEST(Introspection, SourceLocations_TA_Template) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
template<typename T> class A;
template <template <typename> class T> void foo();
void bar()
{
  foo<A>();
}
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(templateArgumentLoc().bind("ta"))), TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *TA = BoundNodes[0].getNodeAs<TemplateArgumentLoc>("ta");

  auto Result = NodeIntrospection::GetLocations(TA);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(
      ExpectedLocations,
      UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getLocation()),
                           STRING_LOCATION_PAIR(TA, getTemplateNameLoc())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getSourceRange())));
}

TEST(Introspection, SourceLocations_TA_TemplateExpansion) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST = buildASTFromCodeWithArgs(
      R"cpp(
template<template<typename> class ...> class B { };
  template<template<typename> class ...T> class C {
  B<T...> testTemplateExpansion;
};
)cpp",
      {"-fno-delayed-template-parsing"}, "foo.cpp", "clang-tool",
      std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(templateArgumentLoc().bind("ta"))), TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *TA = BoundNodes[0].getNodeAs<TemplateArgumentLoc>("ta");

  auto Result = NodeIntrospection::GetLocations(TA);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(
      ExpectedLocations,
      UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getLocation()),
                           STRING_LOCATION_PAIR(TA, getTemplateNameLoc()),
                           STRING_LOCATION_PAIR(TA, getTemplateEllipsisLoc())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getSourceRange())));
}

TEST(Introspection, SourceLocations_TA_Expression) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
template<int, int = 0> class testExpr;
template<int I> class testExpr<I> { };
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(templateArgumentLoc().bind("ta"))), TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *TA = BoundNodes[0].getNodeAs<TemplateArgumentLoc>("ta");

  auto Result = NodeIntrospection::GetLocations(TA);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getLocation())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getSourceRange())));
}

TEST(Introspection, SourceLocations_TA_Pack) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST = buildASTFromCodeWithArgs(
      R"cpp(
template<typename... T> class A {};
void foo()
{
    A<int> ai;
}
)cpp",
      {"-fno-delayed-template-parsing"}, "foo.cpp", "clang-tool",
      std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(templateArgumentLoc().bind("ta"))), TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *TA = BoundNodes[0].getNodeAs<TemplateArgumentLoc>("ta");

  auto Result = NodeIntrospection::GetLocations(TA);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getLocation())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges,
              UnorderedElementsAre(STRING_LOCATION_PAIR(TA, getSourceRange())));
}

TEST(Introspection, SourceLocations_CXXCtorInitializer_base) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
struct A {
};

struct B : A {
  B() : A() {}
};
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(cxxConstructorDecl(
          hasAnyConstructorInitializer(cxxCtorInitializer().bind("init"))))),
      TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *CtorInit = BoundNodes[0].getNodeAs<CXXCtorInitializer>("init");

  auto Result = NodeIntrospection::GetLocations(CtorInit);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(
                  STRING_LOCATION_PAIR(CtorInit, getLParenLoc()),
                  STRING_LOCATION_PAIR(CtorInit, getRParenLoc()),
                  STRING_LOCATION_PAIR(CtorInit, getSourceLocation())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                  CtorInit, getSourceRange())));
}

TEST(Introspection, SourceLocations_CXXCtorInitializer_member) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
struct A {
  int m_i;
  A() : m_i(42) {}
};
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(cxxConstructorDecl(
          hasAnyConstructorInitializer(cxxCtorInitializer().bind("init"))))),
      TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *CtorInit = BoundNodes[0].getNodeAs<CXXCtorInitializer>("init");

  auto Result = NodeIntrospection::GetLocations(CtorInit);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(
                  STRING_LOCATION_PAIR(CtorInit, getLParenLoc()),
                  STRING_LOCATION_PAIR(CtorInit, getMemberLocation()),
                  STRING_LOCATION_PAIR(CtorInit, getRParenLoc()),
                  STRING_LOCATION_PAIR(CtorInit, getSourceLocation())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                  CtorInit, getSourceRange())));
}

TEST(Introspection, SourceLocations_CXXCtorInitializer_ctor) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
struct C {
  C() : C(42) {}
  C(int) {}
};
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(cxxConstructorDecl(
          hasAnyConstructorInitializer(cxxCtorInitializer().bind("init"))))),
      TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *CtorInit = BoundNodes[0].getNodeAs<CXXCtorInitializer>("init");

  auto Result = NodeIntrospection::GetLocations(CtorInit);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(
                  STRING_LOCATION_PAIR(CtorInit, getLParenLoc()),
                  STRING_LOCATION_PAIR(CtorInit, getRParenLoc()),
                  STRING_LOCATION_PAIR(CtorInit, getSourceLocation())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                  CtorInit, getSourceRange())));
}

TEST(Introspection, SourceLocations_CXXCtorInitializer_pack) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST = buildASTFromCodeWithArgs(
      R"cpp(
template<typename... T>
struct Templ {
};

template<typename... T>
struct D : Templ<T...> {
  D(T... t) : Templ<T>(t)... {}
};
)cpp",
      {"-fno-delayed-template-parsing"}, "foo.cpp", "clang-tool",
      std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(cxxConstructorDecl(
          hasAnyConstructorInitializer(cxxCtorInitializer().bind("init"))))),
      TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *CtorInit = BoundNodes[0].getNodeAs<CXXCtorInitializer>("init");

  auto Result = NodeIntrospection::GetLocations(CtorInit);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(
                  STRING_LOCATION_PAIR(CtorInit, getEllipsisLoc()),
                  STRING_LOCATION_PAIR(CtorInit, getLParenLoc()),
                  STRING_LOCATION_PAIR(CtorInit, getMemberLocation()),
                  STRING_LOCATION_PAIR(CtorInit, getRParenLoc()),
                  STRING_LOCATION_PAIR(CtorInit, getSourceLocation())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                  CtorInit, getSourceRange())));
}

TEST(Introspection, SourceLocations_CXXBaseSpecifier_plain) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
class A {};
class B : A {};
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(cxxRecordDecl(hasDirectBase(
          cxxBaseSpecifier(hasType(asString("class A"))).bind("base"))))),
      TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *Base = BoundNodes[0].getNodeAs<CXXBaseSpecifier>("base");

  auto Result = NodeIntrospection::GetLocations(Base);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(Base, getBaseTypeLoc()),
                                   STRING_LOCATION_PAIR(Base, getBeginLoc()),
                                   STRING_LOCATION_PAIR(Base, getEndLoc())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                  Base, getSourceRange())));
}

TEST(Introspection, SourceLocations_CXXBaseSpecifier_accessspec) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
class A {};
class B : public A {};
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(cxxRecordDecl(hasDirectBase(
          cxxBaseSpecifier(hasType(asString("class A"))).bind("base"))))),
      TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *Base = BoundNodes[0].getNodeAs<CXXBaseSpecifier>("base");

  auto Result = NodeIntrospection::GetLocations(Base);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(Base, getBaseTypeLoc()),
                                   STRING_LOCATION_PAIR(Base, getBeginLoc()),
                                   STRING_LOCATION_PAIR(Base, getEndLoc())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                  Base, getSourceRange())));
}

TEST(Introspection, SourceLocations_CXXBaseSpecifier_virtual) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
class A {};
class B {};
class C : virtual B, A {};
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes = ast_matchers::match(
      decl(hasDescendant(cxxRecordDecl(hasDirectBase(
          cxxBaseSpecifier(hasType(asString("class A"))).bind("base"))))),
      TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *Base = BoundNodes[0].getNodeAs<CXXBaseSpecifier>("base");

  auto Result = NodeIntrospection::GetLocations(Base);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(Base, getBaseTypeLoc()),
                                   STRING_LOCATION_PAIR(Base, getBeginLoc()),
                                   STRING_LOCATION_PAIR(Base, getEndLoc())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                  Base, getSourceRange())));
}

TEST(Introspection, SourceLocations_CXXBaseSpecifier_template_base) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST =
      buildASTFromCode(R"cpp(
template<typename T, typename U>
class A {};
class B : A<int, bool> {};
)cpp",
                       "foo.cpp", std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes =
      ast_matchers::match(decl(hasDescendant(cxxRecordDecl(
                              hasDirectBase(cxxBaseSpecifier().bind("base"))))),
                          TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *Base = BoundNodes[0].getNodeAs<CXXBaseSpecifier>("base");

  auto Result = NodeIntrospection::GetLocations(Base);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(Base, getBaseTypeLoc()),
                                   STRING_LOCATION_PAIR(Base, getBeginLoc()),
                                   STRING_LOCATION_PAIR(Base, getEndLoc())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                  Base, getSourceRange())));
}

TEST(Introspection, SourceLocations_CXXBaseSpecifier_pack) {
  if (!NodeIntrospection::hasIntrospectionSupport())
    return;
  auto AST = buildASTFromCodeWithArgs(
      R"cpp(
template<typename... T>
struct Templ : T... {
};
)cpp",
      {"-fno-delayed-template-parsing"}, "foo.cpp", "clang-tool",
      std::make_shared<PCHContainerOperations>());
  auto &Ctx = AST->getASTContext();
  auto &TU = *Ctx.getTranslationUnitDecl();

  auto BoundNodes =
      ast_matchers::match(decl(hasDescendant(cxxRecordDecl(
                              hasDirectBase(cxxBaseSpecifier().bind("base"))))),
                          TU, Ctx);

  EXPECT_EQ(BoundNodes.size(), 1u);

  const auto *Base = BoundNodes[0].getNodeAs<CXXBaseSpecifier>("base");

  auto Result = NodeIntrospection::GetLocations(Base);

  auto ExpectedLocations =
      FormatExpected<SourceLocation>(Result.LocationAccessors);

  EXPECT_THAT(ExpectedLocations,
              UnorderedElementsAre(STRING_LOCATION_PAIR(Base, getBaseTypeLoc()),
                                   STRING_LOCATION_PAIR(Base, getEllipsisLoc()),
                                   STRING_LOCATION_PAIR(Base, getBeginLoc()),
                                   STRING_LOCATION_PAIR(Base, getEndLoc())));

  auto ExpectedRanges = FormatExpected<SourceRange>(Result.RangeAccessors);

  EXPECT_THAT(ExpectedRanges, UnorderedElementsAre(STRING_LOCATION_PAIR(
                                  Base, getSourceRange())));
}