[AST][Introspection] Add a check to detect if introspection is supported.

[njames93]

Summary

This could probably be made into a compile time constant, but that would involve generating a second inc file.

clang/include/clang/Tooling/NodeIntrospection.h

 using SourceRangeMap = UniqueMultiMap<SourceRange, SharedLocationCall>;
 
 struct NodeLocationAccessors {
   SourceLocationMap LocationAccessors;
   SourceRangeMap RangeAccessors;
 };
 
 namespace NodeIntrospection {
+bool hasIntrospectionSupport();
 NodeLocationAccessors GetLocations(clang::Stmt const *Object);
 NodeLocationAccessors GetLocations(clang::Decl const *Object);
 NodeLocationAccessors GetLocations(clang::CXXCtorInitializer const *Object);
 NodeLocationAccessors GetLocations(clang::NestedNameSpecifierLoc const *);
 NodeLocationAccessors GetLocations(clang::TemplateArgumentLoc const *);
 NodeLocationAccessors GetLocations(clang::CXXBaseSpecifier const *);
 NodeLocationAccessors GetLocations(clang::DynTypedNode const &Node);
 } // namespace NodeIntrospection
 } // namespace tooling
 } // namespace clang
 #endif

clang/lib/Tooling/CMakeLists.txt

if (NOT Python3_EXECUTABLE
     OR NOT LLVM_NATIVE_ARCH IN_LIST LLVM_TARGETS_TO_BUILD
     OR NOT X86 IN_LIST LLVM_TARGETS_TO_BUILD
     )
   file(GENERATE OUTPUT ${BINARY_INCLUDE_DIR}/NodeIntrospection.inc
     CONTENT "
 namespace clang {
 namespace tooling {
 
+bool NodeIntrospection::hasIntrospectionSupport() { return false; }
+
 NodeLocationAccessors NodeIntrospection::GetLocations(clang::Stmt const *) {
   return {};
 }
 NodeLocationAccessors NodeIntrospection::GetLocations(clang::Decl const *) {
   return {};
 }
 NodeLocationAccessors NodeIntrospection::GetLocations(
     clang::CXXCtorInitializer const *) {

clang/lib/Tooling/DumpTool/generate_cxx_src_locs.py

 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
 
 namespace clang {
 namespace tooling {
 
 using LocationAndString = SourceLocationMap::value_type;
 using RangeAndString = SourceRangeMap::value_type;
+
+bool NodeIntrospection::hasIntrospectionSupport() { return true; }
 """
 
     def GenerateBaseGetLocationsDeclaration(self, CladeName):
         self.implementationContent += \
             """
 void GetLocationsImpl(SharedLocationCall const& Prefix,
     clang::{0} const *Object, SourceLocationMap &Locs,
     SourceRangeMap &Rngs);
def main():
 
     if use_empty_implementation:
         with open(os.path.join(os.getcwd(),
                   options.output_file), 'w') as f:
             f.write("""
 namespace clang {
 namespace tooling {
 
+bool NodeIntrospection::hasIntrospectionSupport() { return false; }
+
 NodeLocationAccessors NodeIntrospection::GetLocations(clang::Stmt const *) {
   return {};
 }
 NodeLocationAccessors NodeIntrospection::GetLocations(clang::Decl const *) {
   return {};
 }
 NodeLocationAccessors NodeIntrospection::GetLocations(
     clang::CXXCtorInitializer const *) {

clang/unittests/Introspection/IntrospectionTest.cpp

llvm::transform(llvm::make_filter_range(Accessors,
                                           Accessor.first);
                   });
   return Result;
 }
 
 #define STRING_LOCATION_PAIR(INSTANCE, LOC) Pair(#LOC, INSTANCE->LOC)
 
 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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty())
-  {
-    return;
-  }
-
   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>
auto BoundNodes = ast_matchers::match(
       TU, Ctx);
 
   EXPECT_EQ(BoundNodes.size(), 1u);
 
   const auto *MethodDecl = BoundNodes[0].getNodeAs<CXXMethodDecl>("method");
 
   auto Result = NodeIntrospection::GetLocations(MethodDecl);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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()),
EXPECT_THAT(
       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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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()
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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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...> {
auto BoundNodes = ast_matchers::match(
       TU, Ctx);
 
   EXPECT_EQ(BoundNodes.size(), 1u);
 
   const auto *CtorInit = BoundNodes[0].getNodeAs<CXXCtorInitializer>("init");
 
   auto Result = NodeIntrospection::GetLocations(CtorInit);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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);
 
-  if (Result.LocationAccessors.empty() && Result.RangeAccessors.empty()) {
-    return;
-  }
-
   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())));
 }