Merge branch 'development' into f-ClangTidyIdentifierRenameControlFlow

Author: pdschubert

include/phasar/Config/Configuration.h

@@ -35,51 +35,59 @@ namespace psr {
 class PhasarConfig {
 public:
   /// Current Phasar version
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static std::string PhasarVersion() { return XSTR(PHASAR_VERSION); }
 
   /// Stores the label/ tag with which we annotate the LLVM IR.
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static std::string MetaDataKind() { return "psr.id"; }
 
-  static std::string ConfigurationDirectory() {
-    return configuration_directory;
-  }
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  static std::string ConfigurationDirectory() { return ConfigDir; }
 
   /// Specifies the directory in which Phasar is located.
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static std::string PhasarDirectory() { return PhasarDir; }
 
   /// Name of the file storing all standard header search paths used for
   /// compilation.
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static std::string HeaderSearchPathsFileName() {
     return "standard_header_paths.conf";
   }
 
   /// Name of the compile_commands.json file (in case we wish to rename)
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static std::string CompileCommandsJson() { return "compile_commands.json"; }
 
   /// Default Source- and Sink-Functions path
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static std::string DefaultSourceSinkFunctionsPath() {
     return std::string(PhasarDirectory() +
                        "config/phasar-source-sink-function.json");
   }
 
   // Variables to be used in JSON export format
   /// Identifier for call graph export
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static std::string JsonCallGraphID() { return "psr.cg"; }
 
   /// Identifier for type hierarchy graph export
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static std::string JsonTypeHierarchyID() { return "psr.th"; }
 
   /// Identifier for points-to graph export
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static std::string JsonPointsToGraphID() { return "psr.pt"; }
 
   /// Identifier for data-flow results export
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static std::string JsonDataFlowID() { return "psr.df"; }
 
   static PhasarConfig &getPhasarConfig();
 
   llvm::iterator_range<std::set<std::string>::iterator> specialFunctionNames() {
-    return llvm::make_range(special_function_names.begin(),
-                            special_function_names.end());
+    return llvm::make_range(SpecialFuncNames.begin(), SpecialFuncNames.end());
   }
 
   /// Add a function name to the special functions list.
@@ -89,41 +97,44 @@ class PhasarConfig {
   /// Remark: Manually added special functions need to be added before creating
   /// the analysis.
   void addSpecialFunctionName(std::string SFName) {
-    special_function_names.insert(std::move(SFName));
+    SpecialFuncNames.insert(std::move(SFName));
   }
 
   /// Variables map of the parsed command-line parameters
+  // NOLINTNEXTLINE(readability-identifier-naming)
   static boost::program_options::variables_map &VariablesMap() {
-    static boost::program_options::variables_map variables_map;
-    return variables_map;
+    static boost::program_options::variables_map VMap;
+    return VMap;
   }
 
   ~PhasarConfig() = default;
   PhasarConfig(const PhasarConfig &) = delete;
+  PhasarConfig operator=(const PhasarConfig &) = delete;
   PhasarConfig(PhasarConfig &&) = delete;
+  PhasarConfig operator=(PhasarConfig &&) = delete;
 
 private:
   PhasarConfig();
 
-  static std::string readConfigFile(const std::string &path);
+  static std::string readConfigFile(const std::string &Path);
   void loadGlibcSpecialFunctionNames();
   void loadLLVMSpecialFunctionNames();
 
-  std::set<std::string> special_function_names;
+  std::set<std::string> SpecialFuncNames;
 
   /// Specifies the directory in which important configuration files are
   /// located.
-  inline static const std::string configuration_directory = []() {
-    auto *env_home = std::getenv("HOME");
-    std::string config_folder = "config/";
-    if (env_home) { // Check if HOME was defined in the environment
-      std::string phasar_config = std::string(env_home) + "/.config/phasar/";
-      if (boost::filesystem::exists(phasar_config) &&
-          boost::filesystem::is_directory(phasar_config)) {
-        config_folder = phasar_config;
+  inline static const std::string ConfigDir = []() {
+    auto *EnvHome = std::getenv("HOME");
+    std::string ConfigFolder = "config/";
+    if (EnvHome) { // Check if HOME was defined in the environment
+      std::string PhasarConfDir = std::string(EnvHome) + "/.config/phasar/";
+      if (boost::filesystem::exists(PhasarConfDir) &&
+          boost::filesystem::is_directory(PhasarConfDir)) {
+        ConfigFolder = PhasarConfDir;
       }
     }
-    return config_folder;
+    return ConfigFolder;
   }();
 
   /// Specifies the directory in which Phasar is located.

include/phasar/Controller/AnalysisController.h

@@ -128,8 +128,9 @@ class AnalysisController {
   ~AnalysisController() = default;
 
   AnalysisController(const AnalysisController &) = delete;
-
   AnalysisController(AnalysisController &&) = delete;
+  AnalysisController &operator=(const AnalysisController &) = delete;
+  AnalysisController &operator=(const AnalysisController &&) = delete;
 
   void executeAs(AnalysisStrategy Strategy);
 };

include/phasar/DB/Hexastore.h

@@ -25,26 +25,29 @@ namespace psr {
 /**
  * @brief Holds the results of a query to the Hexastore.
  */
-struct hs_result {
+struct HSResult {
   /// Used for the source node.
-  std::string subject;
+  std::string Subject;
   /// Used for the edge.
-  std::string predicate;
+  std::string Predicate;
   /// Used for the destination node.
-  std::string object;
-  hs_result() = default;
-  hs_result(std::string s, std::string p, std::string o)
-      : subject(s), predicate(p), object(o) {}
+  std::string Object;
+  HSResult() = default;
+  HSResult(const std::string Subject, // NOLINT
+           std::string Predicate,     // NOLINT
+           std::string Object)        // NOLINT
+      : Subject(Subject), Predicate(std::move(Predicate)),
+        Object(std::move(Object)) {}
   /// Prints an entry of the results to the command-line
-  friend std::ostream &operator<<(std::ostream &os, const hs_result &hsr) {
-    return os << "[ subject: " << hsr.subject
-              << " | predicate: " << hsr.predicate
-              << " | object: " << hsr.object << " ]";
+  friend std::ostream &operator<<(std::ostream &OS, const HSResult &Result) {
+    return OS << "[ subject: " << Result.Subject
+              << " | predicate: " << Result.Predicate
+              << " | object: " << Result.Object << " ]";
   }
 
-  friend bool operator==(const hs_result LHS, const hs_result RHS) {
-    return LHS.subject == RHS.subject && LHS.predicate == RHS.predicate &&
-           LHS.object == RHS.object;
+  friend bool operator==(const HSResult &LHS, const HSResult &RHS) {
+    return LHS.Subject == RHS.Subject && LHS.Predicate == RHS.Predicate &&
+           LHS.Object == RHS.Object;
   }
 };
 /**
@@ -67,9 +70,10 @@ struct hs_result {
  */
 class Hexastore {
 private:
-  sqlite3 *hs_internal_db{};
-  static int callback(void *NotUsed, int argc, char **argv, char **azColName);
-  void doPut(const std::string &query, std::array<std::string, 3> edge);
+  sqlite3 *HSInternalDB{};
+  static int callback(void * /*NotUsed*/, int Argc, char **Argv,
+                      char **AzColName);
+  void doPut(const std::string &Query, std::array<std::string, 3> Edge);
 
 public:
   /**
@@ -80,7 +84,9 @@ class Hexastore {
    * @brief Constructs a Hexastore under the given filename.
    * @param filename Filename of the Hexastore.
    */
-  Hexastore(const std::string &filename);
+  Hexastore(const std::string &FileName);
+  Hexastore(const Hexastore &) = delete;
+  Hexastore &operator=(const Hexastore &) = delete;
 
   /**
    * Destructor.
@@ -98,7 +104,7 @@ class Hexastore {
    *        hexastore.put({{"subject", "predicate", "object"}});
    * @param edge New entry in the form of a 3-tuple.
    */
-  void put(const std::array<std::string, 3> &edge);
+  void put(const std::array<std::string, 3> &Edge);
 
   /**
    * A query is always in the form of a 3-tuple (source, edge, destination)
@@ -115,8 +121,8 @@ class Hexastore {
    * @param result_size_hint Used for possible optimization.
    * @return An object of hs_result, holding the queried information.
    */
-  std::vector<hs_result> get(std::array<std::string, 3> EdgeQuery,
-                             size_t ResultSizeHint = 0);
+  std::vector<HSResult> get(std::array<std::string, 3> EdgeQuery,
+                            size_t ResultSizeHint = 0);
 };
 
 } // namespace psr

include/phasar/PhasarLLVM/AnalysisStrategy/WholeProgramAnalysis.h

@@ -124,8 +124,9 @@ class WholeProgramAnalysis {
         DataFlowSolver(ProblemDesc) {}
 
   WholeProgramAnalysis(const WholeProgramAnalysis &) = delete;
-
   WholeProgramAnalysis(WholeProgramAnalysis &&) = delete;
+  WholeProgramAnalysis &operator=(WholeProgramAnalysis &) = delete;
+  WholeProgramAnalysis &operator=(WholeProgramAnalysis &&) = delete;
 
   ~WholeProgramAnalysis() {
     if (OwnsConfig) {

include/phasar/PhasarLLVM/ControlFlow/ICFG.h

@@ -59,33 +59,33 @@ template <typename N, typename F> class ICFG : public virtual CFG<N, F> {
 public:
   ~ICFG() override = default;
 
-  virtual std::set<F> getAllFunctions() const = 0;
+  [[nodiscard]] virtual std::set<F> getAllFunctions() const = 0;
 
-  virtual F getFunction(const std::string &Fun) const = 0;
+  [[nodiscard]] virtual F getFunction(const std::string &Fun) const = 0;
 
-  virtual bool isIndirectFunctionCall(N Stmt) const = 0;
+  [[nodiscard]] virtual bool isIndirectFunctionCall(N Stmt) const = 0;
 
-  virtual bool isVirtualFunctionCall(N Stmt) const = 0;
+  [[nodiscard]] virtual bool isVirtualFunctionCall(N Stmt) const = 0;
 
-  virtual std::set<N> allNonCallStartNodes() const = 0;
+  [[nodiscard]] virtual std::set<N> allNonCallStartNodes() const = 0;
 
-  virtual std::set<F> getCalleesOfCallAt(N Stmt) const = 0;
+  [[nodiscard]] virtual std::set<F> getCalleesOfCallAt(N Stmt) const = 0;
 
-  virtual std::set<N> getCallersOf(F Fun) const = 0;
+  [[nodiscard]] virtual std::set<N> getCallersOf(F Fun) const = 0;
 
-  virtual std::set<N> getCallsFromWithin(F Fun) const = 0;
+  [[nodiscard]] virtual std::set<N> getCallsFromWithin(F Fun) const = 0;
 
-  virtual std::set<N> getReturnSitesOfCallAt(N Stmt) const = 0;
+  [[nodiscard]] virtual std::set<N> getReturnSitesOfCallAt(N Stmt) const = 0;
 
-  const std::vector<F> &getGlobalInitializers() const {
+  [[nodiscard]] const std::vector<F> &getGlobalInitializers() const {
     return GlobalInitializers;
   }
 
   using CFG<N, F>::print; // tell the compiler we wish to have both prints
   virtual void print(std::ostream &OS = std::cout) const = 0;
 
   using CFG<N, F>::getAsJson; // tell the compiler we wish to have both prints
-  virtual nlohmann::json getAsJson() const = 0;
+  [[nodiscard]] virtual nlohmann::json getAsJson() const = 0;
 };
 
 } // namespace psr

include/phasar/PhasarLLVM/ControlFlow/LLVMBasedICFG.h

@@ -183,6 +183,7 @@ class LLVMBasedICFG
                 Soundness S = Soundness::Soundy, bool IncludeGlobals = true);
 
   LLVMBasedICFG(const LLVMBasedICFG &ICF);
+
   LLVMBasedICFG &operator=(const LLVMBasedICFG &) = delete;
 
   ~LLVMBasedICFG() override;

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/DefaultSeeds.h

@@ -25,12 +25,12 @@ namespace psr {
 
 template <typename N, typename D> class DefaultSeeds {
 public:
-  static std::map<N, std::set<D>> make(std::vector<N> node, D zeroNode) {
-    std::map<N, std::set<D>> res;
-    for (N n : node) {
-      res.insert(n, std::set<D>{zeroNode});
+  static std::map<N, std::set<D>> make(std::vector<N> Nodes, D ZeroNode) {
+    std::map<N, std::set<D>> Result;
+    for (N Node : Nodes) {
+      Result.insert(std::move(Node), {ZeroNode});
     }
-    return res;
+    return Result;
   }
 };
 

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/EdgeFact.h

@@ -19,7 +19,7 @@ namespace psr {
 class EdgeFact {
 public:
   virtual ~EdgeFact() = default;
-  virtual void print(std::ostream &os) const = 0;
+  virtual void print(std::ostream &OS) const = 0;
 };
 
 static inline std::ostream &operator<<(std::ostream &OS, const EdgeFact &E) {

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/EdgeFactWrapper.h

@@ -33,8 +33,8 @@ template <typename T> class EdgeFactWrapper : public EdgeFact {
   using l_t = T;
   EdgeFactWrapper(const T &F) : Fact(F) {}
   EdgeFactWrapper(T &&F) : Fact(std::move(F)) {}
-  virtual ~EdgeFactWrapper() = default;
-  const T &get() const { return Fact; }
+  ~EdgeFactWrapper() override = default;
+  [[nodiscard]] const T &get() const { return Fact; }
   void print(std::ostream &OS) const override { OS << Fact << '\n'; }
 };
 

include/phasar/PhasarLLVM/DataFlowSolver/IfdsIde/EdgeFunctionComposer.h

@@ -39,8 +39,8 @@ class EdgeFunctionComposer
 
 private:
   // For debug purpose only
-  const unsigned EFComposer_Id;
-  static inline unsigned CurrEFComposer_Id = 0;
+  const unsigned EFComposerId;
+  static inline unsigned CurrEFComposerId = 0; // NOLINT
 
 protected:
   /// First edge function
@@ -49,17 +49,17 @@ class EdgeFunctionComposer
   EdgeFunctionPtrType G;
 
 public:
-  EdgeFunctionComposer(EdgeFunctionPtrType F, EdgeFunctionPtrType G)
-      : EFComposer_Id(++CurrEFComposer_Id), F(F), G(G) {}
+  EdgeFunctionComposer(EdgeFunctionPtrType &F, EdgeFunctionPtrType &G)
+      : EFComposerId(++CurrEFComposerId), F(F), G(G) {}
 
   ~EdgeFunctionComposer() override = default;
 
   /**
    * Target value computation is implemented as
    *     G(F(source))
    */
-  L computeTarget(L source) override {
-    return G->computeTarget(F->computeTarget(source));
+  L computeTarget(L Source) override {
+    return G->computeTarget(F->computeTarget(Source));
   }
 
   /**
@@ -69,29 +69,30 @@ class EdgeFunctionComposer
    * However, it is advised to immediately reduce the resulting edge function
    * by providing an own implementation of this function.
    */
-  EdgeFunctionPtrType composeWith(EdgeFunctionPtrType secondFunction) override {
-    if (auto *EI = dynamic_cast<EdgeIdentity<L> *>(secondFunction.get())) {
+  EdgeFunctionPtrType composeWith(EdgeFunctionPtrType SecondFunction) override {
+    if (auto *EI = dynamic_cast<EdgeIdentity<L> *>(SecondFunction.get())) {
       return this->shared_from_this();
     }
-    if (auto *AB = dynamic_cast<AllBottom<L> *>(secondFunction.get())) {
+    if (auto *AB = dynamic_cast<AllBottom<L> *>(SecondFunction.get())) {
       return this->shared_from_this();
     }
-    return F->composeWith(G->composeWith(secondFunction));
+    return F->composeWith(G->composeWith(SecondFunction));
   }
 
   // virtual EdgeFunctionPtrType
   // joinWith(EdgeFunctionPtrType otherFunction) = 0;
 
-  bool equal_to(EdgeFunctionPtrType other) const override {
-    if (auto EFC = dynamic_cast<EdgeFunctionComposer<L> *>(other.get())) {
+  bool equal_to // NOLINT - would break too many client analyses
+      (EdgeFunctionPtrType Other) const override {
+    if (auto EFC = dynamic_cast<EdgeFunctionComposer<L> *>(Other.get())) {
       return F->equal_to(EFC->F) && G->equal_to(EFC->G);
     }
     return false;
   }
 
-  void print(std::ostream &OS, bool isForDebug = false) const override {
+  void print(std::ostream &OS, bool /*IsForDebug = false*/) const override {
     OS << "COMP[ " << F.get()->str() << " , " << G.get()->str()
-       << " ] (EF:" << EFComposer_Id << ')';
+       << " ] (EF:" << EFComposerId << ')';
   }
 };