//===- unittests/StaticAnalyzer/RegisterCustomCheckersTest.cpp ------------===//
//
// 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 "CheckerRegistration.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
#include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
#include "clang/StaticAnalyzer/Core/Checker.h"
#include "clang/StaticAnalyzer/Core/CheckerRegistryData.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
#include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
#include "clang/StaticAnalyzer/Frontend/AnalysisConsumer.h"
#include "clang/StaticAnalyzer/Frontend/CheckerRegistry.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/Support/raw_ostream.h"
#include "gtest/gtest.h"
#include <memory>

namespace clang {
namespace ento {
namespace {

//===----------------------------------------------------------------------===//
// Just a minimal test for how checker registration works with statically
// linked, non TableGen generated checkers.
//===----------------------------------------------------------------------===//

class CustomChecker : public Checker<check::ASTCodeBody> {
public:
  void checkASTCodeBody(const Decl *D, AnalysisManager &Mgr,
                        BugReporter &BR) const {
    BR.EmitBasicReport(D, this, "Custom diagnostic", categories::LogicError,
                       "Custom diagnostic description",
                       PathDiagnosticLocation(D, Mgr.getSourceManager()), {});
  }
};

void addCustomChecker(AnalysisASTConsumer &AnalysisConsumer,
                      AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.CustomChecker", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) {
    Registry.addChecker<CustomChecker>("test.CustomChecker", "Description", "");
  });
}

TEST(RegisterCustomCheckers, RegisterChecker) {
  std::string Diags;
  EXPECT_TRUE(runCheckerOnCode<addCustomChecker>("void f() {;}", Diags));
  EXPECT_EQ(Diags, "test.CustomChecker: Custom diagnostic description\n");
}

//===----------------------------------------------------------------------===//
// Pretty much the same.
//===----------------------------------------------------------------------===//

class LocIncDecChecker : public Checker<check::Location> {
public:
  void checkLocation(SVal Loc, bool IsLoad, const Stmt *S,
                     CheckerContext &C) const {
    const auto *UnaryOp = dyn_cast<UnaryOperator>(S);
    if (UnaryOp && !IsLoad) {
      EXPECT_FALSE(UnaryOp->isIncrementOp());
    }
  }
};

void addLocIncDecChecker(AnalysisASTConsumer &AnalysisConsumer,
                         AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.LocIncDecChecker", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) {
    Registry.addChecker<CustomChecker>("test.LocIncDecChecker", "Description",
                                       "");
  });
}

TEST(RegisterCustomCheckers, CheckLocationIncDec) {
  EXPECT_TRUE(
      runCheckerOnCode<addLocIncDecChecker>("void f() { int *p; (*p)++; }"));
}

//===----------------------------------------------------------------------===//
// Unsatisfied checker dependency
//===----------------------------------------------------------------------===//

class CheckerRegistrationOrderPrinter
    : public Checker<check::PreStmt<DeclStmt>> {
  std::unique_ptr<BuiltinBug> BT =
      std::make_unique<BuiltinBug>(this, "Registration order");

public:
  void checkPreStmt(const DeclStmt *DS, CheckerContext &C) const {
    ExplodedNode *N = nullptr;
    N = C.generateErrorNode();
    llvm::SmallString<200> Buf;
    llvm::raw_svector_ostream OS(Buf);
    C.getAnalysisManager()
        .getCheckerManager()
        ->getCheckerRegistryData()
        .printEnabledCheckerList(OS);
    // Strip a newline off.
    auto R =
        std::make_unique<PathSensitiveBugReport>(*BT, OS.str().drop_back(1), N);
    C.emitReport(std::move(R));
  }
};

void registerCheckerRegistrationOrderPrinter(CheckerManager &mgr) {
  mgr.registerChecker<CheckerRegistrationOrderPrinter>();
}

bool shouldRegisterCheckerRegistrationOrderPrinter(const CheckerManager &mgr) {
  return true;
}

void addCheckerRegistrationOrderPrinter(CheckerRegistry &Registry) {
  Registry.addChecker(registerCheckerRegistrationOrderPrinter,
                      shouldRegisterCheckerRegistrationOrderPrinter,
                      "test.RegistrationOrder", "Description", "", false);
}

#define UNITTEST_CHECKER(CHECKER_NAME, DIAG_MSG)                               \
  class CHECKER_NAME : public Checker<check::PreStmt<DeclStmt>> {              \
    std::unique_ptr<BuiltinBug> BT =                                           \
        std::make_unique<BuiltinBug>(this, DIAG_MSG);                          \
                                                                               \
  public:                                                                      \
    void checkPreStmt(const DeclStmt *DS, CheckerContext &C) const {}          \
  };                                                                           \
                                                                               \
  void register##CHECKER_NAME(CheckerManager &mgr) {                           \
    mgr.registerChecker<CHECKER_NAME>();                                       \
  }                                                                            \
                                                                               \
  bool shouldRegister##CHECKER_NAME(const CheckerManager &mgr) {               \
    return true;                                                               \
  }                                                                            \
  void add##CHECKER_NAME(CheckerRegistry &Registry) {                          \
    Registry.addChecker(register##CHECKER_NAME, shouldRegister##CHECKER_NAME,  \
                        "test." #CHECKER_NAME, "Description", "", false);      \
  }

UNITTEST_CHECKER(StrongDep, "Strong")
UNITTEST_CHECKER(Dep, "Dep")

bool shouldRegisterStrongFALSE(const CheckerManager &mgr) {
  return false;
}


void addDep(AnalysisASTConsumer &AnalysisConsumer,
                  AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([](CheckerRegistry &Registry) {
    Registry.addChecker(registerStrongDep, shouldRegisterStrongFALSE,
                        "test.Strong", "Description", "", false);
    addStrongDep(Registry);
    addDep(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addDependency("test.Dep", "test.Strong");
  });
}

TEST(RegisterDeps, UnsatisfiedDependency) {
  std::string Diags;
  EXPECT_TRUE(runCheckerOnCode<addDep>("void f() {int i;}", Diags));
  EXPECT_EQ(Diags, "test.RegistrationOrder: test.RegistrationOrder\n");
}

//===----------------------------------------------------------------------===//
// Weak checker dependencies.
//===----------------------------------------------------------------------===//

UNITTEST_CHECKER(WeakDep, "Weak")

void addWeakDepCheckerBothEnabled(AnalysisASTConsumer &AnalysisConsumer,
                                  AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.WeakDep", true},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addWeakDep(Registry);
    addDep(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
  });
}

void addWeakDepCheckerBothEnabledSwitched(AnalysisASTConsumer &AnalysisConsumer,
                                          AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.WeakDep", true},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addWeakDep(Registry);
    addDep(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addWeakDependency("test.WeakDep", "test.Dep");
  });
}

void addWeakDepCheckerDepDisabled(AnalysisASTConsumer &AnalysisConsumer,
                                  AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.WeakDep", false},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addWeakDep(Registry);
    addDep(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
  });
}

void addWeakDepCheckerDepUnspecified(AnalysisASTConsumer &AnalysisConsumer,
                                     AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addWeakDep(Registry);
    addDep(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
  });
}

UNITTEST_CHECKER(WeakDep2, "Weak2")
UNITTEST_CHECKER(Dep2, "Dep2")

void addWeakDepHasWeakDep(AnalysisASTConsumer &AnalysisConsumer,
                          AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.WeakDep", true},
                                {"test.WeakDep2", true},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addStrongDep(Registry);
    addWeakDep(Registry);
    addWeakDep2(Registry);
    addDep(Registry);
    addDep2(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
    Registry.addWeakDependency("test.WeakDep", "test.WeakDep2");
  });
}

void addWeakDepTransitivity(AnalysisASTConsumer &AnalysisConsumer,
                            AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.WeakDep", false},
                                {"test.WeakDep2", true},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addStrongDep(Registry);
    addWeakDep(Registry);
    addWeakDep2(Registry);
    addDep(Registry);
    addDep2(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
    Registry.addWeakDependency("test.WeakDep", "test.WeakDep2");
  });
}

TEST(RegisterDeps, SimpleWeakDependency) {
  std::string Diags;
  EXPECT_TRUE(runCheckerOnCode<addWeakDepCheckerBothEnabled>(
      "void f() {int i;}", Diags));
  EXPECT_EQ(Diags, "test.RegistrationOrder: test.WeakDep\ntest."
                   "Dep\ntest.RegistrationOrder\n");
  Diags.clear();

  // Mind that AnalyzerOption listed the enabled checker list in the same order,
  // but the dependencies are switched.
  EXPECT_TRUE(runCheckerOnCode<addWeakDepCheckerBothEnabledSwitched>(
      "void f() {int i;}", Diags));
  EXPECT_EQ(Diags, "test.RegistrationOrder: test.Dep\ntest."
                   "RegistrationOrder\ntest.WeakDep\n");
  Diags.clear();

  // Weak dependencies dont prevent dependent checkers from being enabled.
  EXPECT_TRUE(runCheckerOnCode<addWeakDepCheckerDepDisabled>(
      "void f() {int i;}", Diags));
  EXPECT_EQ(Diags,
            "test.RegistrationOrder: test.Dep\ntest.RegistrationOrder\n");
  Diags.clear();

  // Nor will they be enabled just because a dependent checker is.
  EXPECT_TRUE(runCheckerOnCode<addWeakDepCheckerDepUnspecified>(
      "void f() {int i;}", Diags));
  EXPECT_EQ(Diags,
            "test.RegistrationOrder: test.Dep\ntest.RegistrationOrder\n");
  Diags.clear();

  EXPECT_TRUE(
      runCheckerOnCode<addWeakDepTransitivity>("void f() {int i;}", Diags));
  EXPECT_EQ(Diags, "test.RegistrationOrder: test.WeakDep2\ntest."
                   "Dep\ntest.RegistrationOrder\n");
  Diags.clear();

  EXPECT_TRUE(
      runCheckerOnCode<addWeakDepHasWeakDep>("void f() {int i;}", Diags));
  EXPECT_EQ(Diags, "test.RegistrationOrder: test.WeakDep2\ntest."
                   "WeakDep\ntest.Dep\ntest.RegistrationOrder\n");
  Diags.clear();
}

//===----------------------------------------------------------------------===//
// Interaction of weak and regular checker dependencies.
//===----------------------------------------------------------------------===//

void addWeakDepHasStrongDep(AnalysisASTConsumer &AnalysisConsumer,
                            AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.StrongDep", true},
                                {"test.WeakDep", true},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addStrongDep(Registry);
    addWeakDep(Registry);
    addDep(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addDependency("test.WeakDep", "test.StrongDep");
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
  });
}

void addWeakDepAndStrongDep(AnalysisASTConsumer &AnalysisConsumer,
                            AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.StrongDep", true},
                                {"test.WeakDep", true},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addStrongDep(Registry);
    addWeakDep(Registry);
    addDep(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addDependency("test.Dep", "test.StrongDep");
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
  });
}

void addDisabledWeakDepHasStrongDep(AnalysisASTConsumer &AnalysisConsumer,
                                    AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.StrongDep", true},
                                {"test.WeakDep", false},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addStrongDep(Registry);
    addWeakDep(Registry);
    addDep(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addDependency("test.WeakDep", "test.StrongDep");
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
  });
}

void addDisabledWeakDepHasUnspecifiedStrongDep(
    AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.WeakDep", false},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addStrongDep(Registry);
    addWeakDep(Registry);
    addDep(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addDependency("test.WeakDep", "test.StrongDep");
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
  });
}

void addWeakDepHasDisabledStrongDep(AnalysisASTConsumer &AnalysisConsumer,
                                    AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.StrongDep", false},
                                {"test.WeakDep", true},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addStrongDep(Registry);
    addWeakDep(Registry);
    addDep(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addDependency("test.WeakDep", "test.StrongDep");
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
  });
}

void addWeakDepHasUnspecifiedButLaterEnabledStrongDep(
    AnalysisASTConsumer &AnalysisConsumer, AnalyzerOptions &AnOpts) {
  AnOpts.CheckersAndPackages = {{"test.Dep", true},
                                {"test.Dep2", true},
                                {"test.WeakDep", true},
                                {"test.RegistrationOrder", true}};
  AnalysisConsumer.AddCheckerRegistrationFn([=](CheckerRegistry &Registry) {
    addStrongDep(Registry);
    addWeakDep(Registry);
    addDep(Registry);
    addDep2(Registry);
    addCheckerRegistrationOrderPrinter(Registry);
    Registry.addDependency("test.WeakDep", "test.StrongDep");
    Registry.addDependency("test.Dep2", "test.StrongDep");
    Registry.addWeakDependency("test.Dep", "test.WeakDep");
  });
}

TEST(RegisterDeps, DependencyInteraction) {
  std::string Diags;
  EXPECT_TRUE(
      runCheckerOnCode<addWeakDepHasStrongDep>("void f() {int i;}", Diags));
  EXPECT_EQ(Diags, "test.RegistrationOrder: test.StrongDep\ntest."
                   "WeakDep\ntest.Dep\ntest.RegistrationOrder\n");
  Diags.clear();

  // Weak dependencies are registered before strong dependencies. This is most
  // important for purely diagnostic checkers that are implemented as a part of
  // purely modeling checkers, becuse the checker callback order will have to be
  // established in between the modeling portion and the weak dependency.
  EXPECT_TRUE(
      runCheckerOnCode<addWeakDepAndStrongDep>("void f() {int i;}", Diags));
  EXPECT_EQ(Diags, "test.RegistrationOrder: test.WeakDep\ntest."
                   "StrongDep\ntest.Dep\ntest.RegistrationOrder\n");
  Diags.clear();

  // If a weak dependency is disabled, the checker itself can still be enabled.
  EXPECT_TRUE(runCheckerOnCode<addDisabledWeakDepHasStrongDep>(
      "void f() {int i;}", Diags));
  EXPECT_EQ(Diags, "test.RegistrationOrder: test.Dep\ntest."
                   "RegistrationOrder\ntest.StrongDep\n");
  Diags.clear();

  // If a weak dependency is disabled, the checker itself can still be enabled,
  // but it shouldn't enable a strong unspecified dependency.
  EXPECT_TRUE(runCheckerOnCode<addDisabledWeakDepHasUnspecifiedStrongDep>(
      "void f() {int i;}", Diags));
  EXPECT_EQ(Diags,
            "test.RegistrationOrder: test.Dep\ntest.RegistrationOrder\n");
  Diags.clear();

  // A strong dependency of a weak dependency is disabled, so neither of them
  // should be enabled.
  EXPECT_TRUE(runCheckerOnCode<addWeakDepHasDisabledStrongDep>(
      "void f() {int i;}", Diags));
  EXPECT_EQ(Diags,
            "test.RegistrationOrder: test.Dep\ntest.RegistrationOrder\n");
  Diags.clear();

  EXPECT_TRUE(
      runCheckerOnCode<addWeakDepHasUnspecifiedButLaterEnabledStrongDep>(
          "void f() {int i;}", Diags));
  EXPECT_EQ(Diags, "test.RegistrationOrder: test.StrongDep\ntest.WeakDep\ntest."
                   "Dep\ntest.Dep2\ntest.RegistrationOrder\n");
  Diags.clear();
}
} // namespace
} // namespace ento
} // namespace clang