[clang][dataflow] Remove TestingSupport's dependency on gtest

[ymandel]

Summary

Users outside of the clang repo may use different googletest versions. So, it's
better not to depend on llvm's googletest. This patch removes the dependency by
having checkDataflow return an llvm::Error instead of calling googletest's
FAIL or ASSERT... macros.

[gribozavr2]

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

144

any_cast already performs an assert.

[ymandel]

remove redundant assert.

[jyknight]

Users outside of the clang repo may use different googletest versions.

I don't understand what that means.

Why does it matter what version outside users are using -- these are clang unit-tests, not a public API, right?

[gribozavr2]

Why does it matter what version outside users are using -- these are clang unit-tests, not a public API, right?

clang/unittests/Analysis/FlowSensitive/TestingSupport.h is a public API for writing tests for dataflow analyses.

clang/unittests/Analysis/FlowSensitive/MultiVarConstantPropagationTest.cpp

 #include "clang/Analysis/FlowSensitive/MapLattice.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 
MATCHER_P(HoldsCPLattice, m,
               .str()) {
   return ExplainMatchResult(m, arg.Lattice, result_listener);
 }
 
 class MultiVarConstantPropagationTest : public ::testing::Test {
 protected:
   template <typename Matcher>
   void RunDataflow(llvm::StringRef Code, Matcher Expectations) {
+    ASSERT_THAT_ERROR(
         test::checkDataflow<ConstantPropagationAnalysis>(
             Code, "fun",
             [](ASTContext &C, Environment &) {
               return ConstantPropagationAnalysis(C);
             },
             [&Expectations](
                 llvm::ArrayRef<std::pair<
-                std::string,
-                DataflowAnalysisState<ConstantPropagationAnalysis::Lattice>>>
+                    std::string, DataflowAnalysisState<
+                                     ConstantPropagationAnalysis::Lattice>>>
                     Results,
                 ASTContext &) { EXPECT_THAT(Results, Expectations); },
-        {"-fsyntax-only", "-std=c++17"});
+            {"-fsyntax-only", "-std=c++17"}),
+        llvm::Succeeded());
   }
 };
 
 TEST_F(MultiVarConstantPropagationTest, JustInit) {
   std::string Code = R"(
     void fun() {
       int target = 1;
       // [[p]]

clang/unittests/Analysis/FlowSensitive/SingleVarConstantPropagationTest.cpp

 #include "clang/Analysis/FlowSensitive/DataflowLattice.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/Support/Annotations.h"
+#include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cstdint>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 
MATCHER_P(HoldsCPLattice, m,
               .str()) {
   return ExplainMatchResult(m, arg.Lattice, result_listener);
 }
 
 class ConstantPropagationTest : public ::testing::Test {
 protected:
   template <typename Matcher>
   void RunDataflow(llvm::StringRef Code, Matcher Expectations) {
+    ASSERT_THAT_ERROR(
         test::checkDataflow<ConstantPropagationAnalysis>(
             Code, "fun",
             [](ASTContext &C, Environment &) {
               return ConstantPropagationAnalysis(C);
             },
             [&Expectations](
                 llvm::ArrayRef<std::pair<
-                std::string,
-                DataflowAnalysisState<ConstantPropagationAnalysis::Lattice>>>
+                    std::string, DataflowAnalysisState<
+                                     ConstantPropagationAnalysis::Lattice>>>
                     Results,
                 ASTContext &) { EXPECT_THAT(Results, Expectations); },
-        {"-fsyntax-only", "-std=c++17"});
+            {"-fsyntax-only", "-std=c++17"}),
+        llvm::Succeeded());
   }
 };
 
 TEST_F(ConstantPropagationTest, JustInit) {
   std::string Code = R"(
     void fun() {
       int target = 1;
       // [[p]]

clang/unittests/Analysis/FlowSensitive/TestingSupport.h

 #include "clang/Basic/LLVM.h"
 #include "clang/Serialization/PCHContainerOperations.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Testing/Support/Annotations.h"
-#include "gtest/gtest.h"
 #include <functional>
 #include <memory>
+#include <ostream>
 #include <string>
 #include <utility>
 
 namespace clang {
 namespace dataflow {
 
 // Requires a `<<` operator for the `Lattice` type.
 // FIXME: move to a non-test utility library.

 // `AnnotatedCode`.
 llvm::Expected<llvm::DenseMap<const Stmt *, std::string>>
 buildStatementToAnnotationMapping(const FunctionDecl *Func,
                                   llvm::Annotations AnnotatedCode);
 
 // Runs dataflow on the body of the function that matches `func_matcher` in code
 // snippet `code`. Requires: `Analysis` contains a type `Lattice`.
 template <typename AnalysisT>
-void checkDataflow(
+llvm::Error checkDataflow(
     llvm::StringRef Code,
     ast_matchers::internal::Matcher<FunctionDecl> FuncMatcher,
     std::function<AnalysisT(ASTContext &, Environment &)> MakeAnalysis,
     std::function<void(
         llvm::ArrayRef<std::pair<
             std::string, DataflowAnalysisState<typename AnalysisT::Lattice>>>,
         ASTContext &)>
         Expectations,
     ArrayRef<std::string> Args,
     const tooling::FileContentMappings &VirtualMappedFiles = {}) {
   using StateT = DataflowAnalysisState<typename AnalysisT::Lattice>;
 
   llvm::Annotations AnnotatedCode(Code);
   auto Unit = tooling::buildASTFromCodeWithArgs(
       AnnotatedCode.code(), Args, "input.cc", "clang-dataflow-test",
       std::make_shared<PCHContainerOperations>(),
       tooling::getClangStripDependencyFileAdjuster(), VirtualMappedFiles);
   auto &Context = Unit->getASTContext();
 
   if (Context.getDiagnostics().getClient()->getNumErrors() != 0) {
-    FAIL() << "Source file has syntax or type errors, they were printed to "
-              "the test log";
+    return llvm::make_error<llvm::StringError>(
+        llvm::errc::invalid_argument, "Source file has syntax or type errors, "
+                                      "they were printed to the test log");
   }
 
   const FunctionDecl *F = ast_matchers::selectFirst<FunctionDecl>(
       "target",
       ast_matchers::match(
           ast_matchers::functionDecl(ast_matchers::isDefinition(), FuncMatcher)
               .bind("target"),
           Context));
-  ASSERT_TRUE(F != nullptr) << "Could not find target function.";
+  if (F == nullptr)
+    return llvm::make_error<llvm::StringError>(
+        llvm::errc::invalid_argument, "Could not find target function.");
 
   auto CFCtx = ControlFlowContext::build(F, F->getBody(), &F->getASTContext());
-  ASSERT_TRUE((bool)CFCtx) << "Could not build ControlFlowContext.";
+  if (!CFCtx)
+    return CFCtx.takeError();
 
   DataflowAnalysisContext DACtx;
   Environment Env(DACtx, *F);
   auto Analysis = MakeAnalysis(Context, Env);
 
   llvm::Expected<llvm::DenseMap<const clang::Stmt *, std::string>>
       StmtToAnnotations = buildStatementToAnnotationMapping(F, AnnotatedCode);
-  if (auto E = StmtToAnnotations.takeError()) {
-    FAIL() << "Failed to build annotation map: "
-           << llvm::toString(std::move(E));
-    return;
-  }
+  if (!StmtToAnnotations)
+    return StmtToAnnotations.takeError();
+
   auto &Annotations = *StmtToAnnotations;
 
   std::vector<llvm::Optional<TypeErasedDataflowAnalysisState>> BlockStates =
       runTypeErasedDataflowAnalysis(*CFCtx, Analysis, Env);
 
   if (BlockStates.empty()) {
     Expectations({}, Context);
-    return;
+    return llvm::Error::success();
   }
 
   // Compute a map from statement annotations to the state computed for
   // the program point immediately after the annotated statement.
   std::vector<std::pair<std::string, StateT>> Results;
   for (const CFGBlock *Block : CFCtx->getCFG()) {
     // Skip blocks that were not evaluated.
     if (!BlockStates[Block->getBlockID()].hasValue())
       continue;
 
     transferBlock(
         *CFCtx, BlockStates, *Block, Env, Analysis,
         [&Results, &Annotations](const clang::CFGStmt &Stmt,
                                  const TypeErasedDataflowAnalysisState &State) {
           auto It = Annotations.find(Stmt.getStmt());
           if (It == Annotations.end())
             return;
-          if (auto *Lattice = llvm::any_cast<typename AnalysisT::Lattice>(
-                  &State.Lattice.Value)) {
-            Results.emplace_back(It->second, StateT{*Lattice, State.Env});
-          } else {
-            FAIL() << "Could not cast lattice element to expected type.";
-          }
+          auto *Lattice =
+              llvm::any_cast<typename AnalysisT::Lattice>(&State.Lattice.Value);
         });
   }
   Expectations(Results, Context);
+  return llvm::Error::success();
 }
 
 // Runs dataflow on the body of the function named `target_fun` in code snippet
 // `code`.
 template <typename AnalysisT>
-void checkDataflow(
+llvm::Error checkDataflow(
     llvm::StringRef Code, llvm::StringRef TargetFun,
     std::function<AnalysisT(ASTContext &, Environment &)> MakeAnalysis,
     std::function<void(
         llvm::ArrayRef<std::pair<
             std::string, DataflowAnalysisState<typename AnalysisT::Lattice>>>,
         ASTContext &)>
         Expectations,
     ArrayRef<std::string> Args,
     const tooling::FileContentMappings &VirtualMappedFiles = {}) {
-  checkDataflow(Code, ast_matchers::hasName(TargetFun), std::move(MakeAnalysis),
-                std::move(Expectations), Args, VirtualMappedFiles);
+  return checkDataflow(Code, ast_matchers::hasName(TargetFun),
+                       std::move(MakeAnalysis), std::move(Expectations), Args,
+                       VirtualMappedFiles);
 }
 
 } // namespace test
 } // namespace dataflow
 } // namespace clang
 
 #endif // LLVM_CLANG_ANALYSIS_FLOW_SENSITIVE_TESTING_SUPPORT_H_

clang/unittests/Analysis/FlowSensitive/TestingSupport.cpp

 #include "clang/Serialization/PCHContainerOperations.h"
 #include "clang/Tooling/ArgumentsAdjusters.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Testing/Support/Annotations.h"
-#include "gtest/gtest.h"
 #include <functional>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <utility>
 #include <vector>
 
 using namespace clang;
 using namespace dataflow;
 
-namespace {
-using ast_matchers::MatchFinder;
-
-class FindTranslationUnitCallback : public MatchFinder::MatchCallback {
-public:
-  explicit FindTranslationUnitCallback(
-      std::function<void(ASTContext &)> Operation)
-      : Operation{Operation} {}
-
-  void run(const MatchFinder::MatchResult &Result) override {
-    const auto *TU = Result.Nodes.getNodeAs<TranslationUnitDecl>("tu");
-    if (TU->getASTContext().getDiagnostics().getClient()->getNumErrors() != 0) {
-      FAIL() << "Source file has syntax or type errors, they were printed to "
-                "the test log";
-    }
-    Operation(TU->getASTContext());
-  }
-
-  std::function<void(ASTContext &)> Operation;
-};
-} // namespace
-
 static bool
 isAnnotationDirectlyAfterStatement(const Stmt *Stmt, unsigned AnnotationBegin,
                                    const SourceManager &SourceManager,
                                    const LangOptions &LangOptions) {
   auto NextToken =
       Lexer::findNextToken(Stmt->getEndLoc(), SourceManager, LangOptions);
 
   while (NextToken.hasValue() &&

clang/unittests/Analysis/FlowSensitive/TestingSupportTest.cpp

 #include "TestingSupport.h"
 #include "NoopAnalysis.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Tooling/Tooling.h"
+#include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace dataflow;
 
 namespace {
 

 }
 
 void checkDataflow(
     llvm::StringRef Code, llvm::StringRef Target,
     std::function<void(llvm::ArrayRef<std::pair<
                            std::string, DataflowAnalysisState<NoopLattice>>>,
                        ASTContext &)>
         Expectations) {
-  test::checkDataflow<NoopAnalysis>(
-      Code, Target,
-      [](ASTContext &Context, Environment &) { return NoopAnalysis(Context); },
-      std::move(Expectations), {"-fsyntax-only", "-std=c++17"});
+  ASSERT_THAT_ERROR(
+      test::checkDataflow<NoopAnalysis>(Code, Target,
+                                        [](ASTContext &Context, Environment &) {
+                                          return NoopAnalysis(Context);
+                                        },
+                                        std::move(Expectations),
+                                        {"-fsyntax-only", "-std=c++17"}),
+      llvm::Succeeded());
 }
 
 TEST(ProgramPointAnnotations, NoAnnotations) {
   ::testing::MockFunction<void(
       llvm::ArrayRef<
           std::pair<std::string, DataflowAnalysisState<NoopLattice>>>,
       ASTContext &)>
       Expectations;

clang/unittests/Analysis/FlowSensitive/TransferTest.cpp

 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
 #include "clang/Analysis/FlowSensitive/StorageLocation.h"
 #include "clang/Analysis/FlowSensitive/Value.h"
 #include "clang/Basic/LangStandard.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cassert>
 #include <string>
 #include <utility>
 
 namespace {
 
 using namespace clang;
 using namespace dataflow;
 using ::testing::_;
 using ::testing::ElementsAre;
 using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::Pair;
 
 class TransferTest : public ::testing::Test {
 protected:
   template <typename Matcher>
   void runDataflow(llvm::StringRef Code, Matcher Match,
                    LangStandard::Kind Std = LangStandard::lang_cxx17) {
+    ASSERT_THAT_ERROR(
         test::checkDataflow<NoopAnalysis>(
             Code, "target",
             [](ASTContext &C, Environment &) { return NoopAnalysis(C); },
-        [&Match](llvm::ArrayRef<
-                     std::pair<std::string, DataflowAnalysisState<NoopLattice>>>
-                     Results,
-                 ASTContext &ASTCtx) { Match(Results, ASTCtx); },
+            [&Match](
+                llvm::ArrayRef<
             {"-fsyntax-only",
              "-std=" +
-             std::string(LangStandard::getLangStandardForKind(Std).getName())});
+                 std::string(
+                     LangStandard::getLangStandardForKind(Std).getName())}),
+        llvm::Succeeded());
   }
 };
 
 /// Returns the `ValueDecl` for the given identifier.
 ///
 /// Requirements:
 ///
 ///  `Name` must be unique in `ASTCtx`.

clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp

 #include "clang/Analysis/FlowSensitive/DataflowAnalysisContext.h"
 #include "clang/Analysis/FlowSensitive/DataflowEnvironment.h"
 #include "clang/Analysis/FlowSensitive/DataflowLattice.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include <cassert>
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
FilesContents.push_back(std::make_pair<std::string, std::string>(
 
       class NonFatal {
        public:
         ~NonFatal();
         int bar();
       };
     )"));
 
+    ASSERT_THAT_ERROR(
         test::checkDataflow<FunctionCallAnalysis>(
             Code, "target",
-        [](ASTContext &C, Environment &) { return FunctionCallAnalysis(C); },
+            [](ASTContext &C, Environment &) {
+              return FunctionCallAnalysis(C);
+            },
             [&Expectations](
                 llvm::ArrayRef<std::pair<
                     std::string, DataflowAnalysisState<FunctionCallLattice>>>
                     Results,
                 ASTContext &) { EXPECT_THAT(Results, Expectations); },
-        {"-fsyntax-only", "-std=c++17"}, FilesContents);
+            {"-fsyntax-only", "-std=c++17"}, FilesContents),
+        llvm::Succeeded());
   }
 };
 
 MATCHER_P(HoldsFunctionCallLattice, m,
           ((negation ? "doesn't hold" : "holds") +
            llvm::StringRef(" a lattice element that ") +
            ::testing::DescribeMatcher<FunctionCallLattice>(m, negation))
               .str()) {