🔧 Add clang-tidy to the project (#105)

This PR adds a project wide `clang-tidy` configuration to QMAP for
ensuring the code quality of the C++ part of the project.
Additionally, it sets up a CI job (using `cpp-linter`) that checks
compliance on every push/pull request.

Author: burgholzer

.clang-tidy

@@ -0,0 +1,70 @@
+FormatStyle: file
+
+Checks: |
+  clang-diagnostic-*,
+  clang-analyzer-*,
+  boost-*,
+  bugprone-*,
+  -bugprone-easily-swappable-parameters,
+  clang-analyzer-*,
+  cppcoreguidelines-*,
+  -cppcoreguidelines-non-private-member-variables-in-classes,
+  -cppcoreguidelines-special-member-functions,
+  -cppcoreguidelines-avoid-magic-numbers,
+  -cppcoreguidelines-macro-usage,
+  google-*,
+  -google-readability-todo,
+  -google-build-using-namespace,
+  misc-*,
+  -misc-no-recursion,
+  -misc-non-private-member-variables-in-classes,
+  modernize-*,
+  -modernize-use-trailing-return-type,
+  performance-*,
+  portability-*,
+  readability-*,
+  -readability-identifier-length,
+  -readability-magic-numbers,
+  -readability-function-cognitive-complexity
+
+CheckOptions:
+  - key: readability-identifier-naming.ClassCase
+    value: CamelCase
+  - key: readability-identifier-naming.ClassIgnoredRegexp
+    value: ".*ZX.*|.*SWAP.*|.*CEX.*|.*DD.*|.*EQ.*"
+  - key: readability-identifier-naming.ConstantParameterCase
+    value: camelBack
+  - key: readability-identifier-naming.EnumCase
+    value: CamelCase
+  - key: readability-identifier-naming.EnumConstantCase
+    value: CamelCase
+  - key: readability-identifier-naming.FunctionCase
+    value: camelBack
+  - key: readability-identifier-naming.FunctionIgnoredRegexp
+    value: ".*ZX.*|.*SWAP.*|.*CEX.*|.*DD.*|.*EQ.*"
+  - key: readability-identifier-naming.GlobalConstantCase
+    value: UPPER_CASE
+  - key: readability-identifier-naming.IgnoreMainLikeFunctions
+    value: "true"
+  - key: readability-identifier-naming.LocalConstantCase
+    value: camelBack
+  - key: readability-identifier-naming.LocalVariableCase
+    value: camelBack
+  - key: readability-identifier-naming.MemberCase
+    value: camelBack
+  - key: readability-identifier-naming.MemberIgnoredRegexp
+    value: ".*ZX.*|.*SWAP.*|.*CEX.*|.*DD.*|.*EQ.*"
+  - key: readability-identifier-naming.MethodCase
+    value: camelBack
+  - key: readability-identifier-naming.ParameterCase
+    value: camelBack
+  - key: readability-identifier-naming.ParameterIgnoredRegexp
+    value: ".*ZX.*|.*SWAP.*|.*CEX.*|.*DD.*|.*EQ.*"
+  - key: readability-identifier-naming.NamespaceCase
+    value: lower_case
+  - key: readability-identifier-naming.StaticConstantCase
+    value: UPPER_CASE
+  - key: readability-identifier-naming.StructCase
+    value: CamelCase
+  - key: readability-identifier-naming.VariableCase
+    value: camelBack

.github/workflows/cpp-linter.yml

@@ -0,0 +1,52 @@
+name: cpp-linter
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+env:
+  Z3_VERSION: 4.11.2
+
+jobs:
+  cpp-linter:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Install Z3
+        uses: cda-tum/setup-z3@v1
+        with:
+          version: ${{ env.Z3_VERSION }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Generate compilation database
+        run: |
+          CC=clang-14 CXX=clang++-14 \
+          cmake -S . -B build \
+          -DBINDINGS=ON \
+          -DBUILD_QMAP_TESTS=ON \
+          -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
+      - name: Run cpp-linter
+        id: linter
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          pipx run cpp-linter \
+          --version=14 \
+          --style="file" \
+          --tidy-checks="" \
+          --thread-comments=true \
+          --files-changed-only=true \
+          --ignore="build" \
+          --database=build
+      - name: Fail if linter found errors
+        if: steps.linter.outputs.checks-failed > 0
+        run: echo "Linter found errors" && exit 1

extern/LogicBlocks

@@ -22,19 +22,17 @@ constexpr std::uint8_t GATES_OF_UNIDIRECTIONAL_SWAP = 7U;
 constexpr std::uint8_t GATES_OF_DIRECTION_REVERSE   = 4U;
 constexpr std::uint8_t GATES_OF_TELEPORTATION       = 7U;
 
-constexpr int COST_SINGLE_QUBIT_GATE = 1;
-constexpr int COST_CNOT_GATE         = 10;
-constexpr int COST_MEASUREMENT       = 10;
-constexpr int COST_UNIDIRECTIONAL_SWAP =
+constexpr std::uint32_t COST_SINGLE_QUBIT_GATE = 1;
+constexpr std::uint32_t COST_CNOT_GATE         = 10;
+constexpr std::uint32_t COST_MEASUREMENT       = 10;
+constexpr std::uint32_t COST_UNIDIRECTIONAL_SWAP =
     3 * COST_CNOT_GATE + 4 * COST_SINGLE_QUBIT_GATE;
-constexpr int COST_BIDIRECTIONAL_SWAP = 3 * COST_CNOT_GATE;
-constexpr int COST_TELEPORTATION =
+constexpr std::uint32_t COST_BIDIRECTIONAL_SWAP = 3 * COST_CNOT_GATE;
+constexpr std::uint32_t COST_TELEPORTATION =
     2 * COST_CNOT_GATE + COST_MEASUREMENT + 4 * COST_SINGLE_QUBIT_GATE;
-constexpr int COST_DIRECTION_REVERSE = 4 * COST_SINGLE_QUBIT_GATE;
+constexpr std::uint32_t COST_DIRECTION_REVERSE = 4 * COST_SINGLE_QUBIT_GATE;
 
 class Architecture {
-  static constexpr bool VERBOSE = false;
-
 public:
   class Properties {
   protected:
@@ -208,21 +206,20 @@ class Architecture {
   void loadProperties(std::istream& is);
   void loadProperties(std::istream&& is);
   void loadProperties(const std::string& filename);
-  void loadProperties(const Properties& properties);
+  void loadProperties(const Properties& props);
 
   Architecture() = default;
-  explicit Architecture(const std::string& cm_filename) {
-    loadCouplingMap(cm_filename);
+  explicit Architecture(const std::string& cmFilename) {
+    loadCouplingMap(cmFilename);
   }
-  Architecture(const std::string& cm_filename,
-               const std::string& props_filename)
-      : Architecture(cm_filename) {
-    loadProperties(props_filename);
+  Architecture(const std::string& cmFilename, const std::string& propsFilename)
+      : Architecture(cmFilename) {
+    loadProperties(propsFilename);
   }
 
   Architecture(std::uint16_t nQ, const CouplingMap& couplingMap);
   Architecture(std::uint16_t nQ, const CouplingMap& couplingMap,
-               const Properties& properties);
+               const Properties& props);
 
   [[nodiscard]] std::uint16_t getNqubits() const { return nqubits; }
   void                        setNqubits(std::uint16_t nQ) { nqubits = nQ; }
@@ -234,21 +231,24 @@ class Architecture {
     return couplingMap;
   }
   [[nodiscard]] CouplingMap& getCouplingMap() { return couplingMap; }
-  void                       setCouplingMap(const CouplingMap& cm) {
+
+  void setCouplingMap(const CouplingMap& cm) {
     couplingMap = cm;
     createDistanceTable();
   }
 
-  CouplingMap& getCurrentTeleportations() { return current_teleportations; }
+  CouplingMap& getCurrentTeleportations() { return currentTeleportations; }
   std::vector<std::pair<std::int16_t, std::int16_t>>& getTeleportationQubits() {
     return teleportationQubits;
   }
 
   [[nodiscard]] const Matrix& getDistanceTable() const { return distanceTable; }
 
   [[nodiscard]] const Properties& getProperties() const { return properties; }
-  [[nodiscard]] Properties&       getProperties() { return properties; }
-  void                            setProperties(const Properties& props) {
+
+  [[nodiscard]] Properties& getProperties() { return properties; }
+
+  void setProperties(const Properties& props) {
     properties = props;
     createFidelityTable();
   }
@@ -281,16 +281,15 @@ class Architecture {
 
   [[nodiscard]] double distance(std::uint16_t control,
                                 std::uint16_t target) const {
-    if (current_teleportations.empty()) {
+    if (currentTeleportations.empty()) {
       return distanceTable.at(control).at(target);
-    } else {
-      return static_cast<double>(bfs(control, target, current_teleportations));
     }
+    return static_cast<double>(bfs(control, target, currentTeleportations));
   }
 
   [[nodiscard]] std::set<std::uint16_t> getQubitSet() const {
     std::set<std::uint16_t> result{};
-    for (int i = 0; i < nqubits; ++i) {
+    for (std::uint16_t i = 0; i < nqubits; ++i) {
       result.insert(result.end(),
                     i); // should be constant with gcc, or at most O(nqubits)
     }
@@ -325,13 +324,13 @@ class Architecture {
   getCouplingLimit(const std::set<std::uint16_t>& qubitChoice) const;
 
   void getHighestFidelityCouplingMap(std::uint16_t subsetSize,
-                                     CouplingMap&  couplingMap) const;
+                                     CouplingMap&  reducedMap) const;
   [[nodiscard]] std::vector<QubitSubset>
        getAllConnectedSubsets(std::uint16_t subsetSize) const;
   void getReducedCouplingMaps(std::uint16_t             subsetSize,
                               std::vector<CouplingMap>& couplingMaps) const;
   void getReducedCouplingMap(const QubitSubset& qubitChoice,
-                             CouplingMap&       couplingMap) const;
+                             CouplingMap&       reducedMap) const;
   [[nodiscard]] static double
   getAverageArchitectureFidelity(const CouplingMap& cm,
                                  const QubitSubset& qubitChoice,
@@ -350,12 +349,12 @@ class Architecture {
   static void printCouplingMap(const CouplingMap& cm, std::ostream& os);
 
 protected:
-  std::string   name;
-  std::uint16_t nqubits                = 0;
-  CouplingMap   couplingMap            = {};
-  CouplingMap   current_teleportations = {};
-  bool          isBidirectional        = true;
-  Matrix        distanceTable          = {};
+  std::string                                        name;
+  std::uint16_t                                      nqubits               = 0;
+  CouplingMap                                        couplingMap           = {};
+  CouplingMap                                        currentTeleportations = {};
+  bool                                               isBidirectional = true;
+  Matrix                                             distanceTable   = {};
   std::vector<std::pair<std::int16_t, std::int16_t>> teleportationQubits{};
   Properties                                         properties            = {};
   Matrix                                             fidelityTable         = {};
@@ -364,23 +363,21 @@ class Architecture {
   void createDistanceTable();
   void createFidelityTable();
 
-  static double cost_heuristic_bidirectional(const Dijkstra::Node& node) {
+  static double costHeuristicBidirectional(const Dijkstra::Node& node) {
     auto length = node.cost - 1;
-    if (node.contains_correct_edge) {
+    if (node.containsCorrectEdge) {
       return length * COST_BIDIRECTIONAL_SWAP;
-    } else {
-      throw QMAPException("In a bidrectional architecture it should not happen "
-                          "that a node does not contain the right edge.");
     }
+    throw QMAPException("In a bidrectional architecture it should not happen "
+                        "that a node does not contain the right edge.");
   }
 
-  static double cost_heuristic_unidirectional(const Dijkstra::Node& node) {
+  static double costHeuristicUnidirectional(const Dijkstra::Node& node) {
     auto length = node.cost - 1;
-    if (node.contains_correct_edge) {
+    if (node.containsCorrectEdge) {
       return length * COST_UNIDIRECTIONAL_SWAP;
-    } else {
-      return length * COST_UNIDIRECTIONAL_SWAP + COST_DIRECTION_REVERSE;
     }
+    return length * COST_UNIDIRECTIONAL_SWAP + COST_DIRECTION_REVERSE;
   }
 
   // added for teleportation
@@ -390,12 +387,13 @@ class Architecture {
   [[nodiscard]] std::uint64_t bfs(std::uint16_t start, std::uint16_t goal,
                                   const std::set<Edge>& teleportations) const;
 
-  static std::size_t findCouplingLimit(const CouplingMap& cm, int nQubits);
+  static std::size_t findCouplingLimit(const CouplingMap& cm,
+                                       std::uint16_t      nQubits);
   static std::size_t
-  findCouplingLimit(const CouplingMap& cm, int nQubits,
+  findCouplingLimit(const CouplingMap& cm, std::uint16_t nQubits,
                     const std::set<std::uint16_t>& qubitChoice);
   static void
-  findCouplingLimit(std::uint16_t node, int curSum,
+  findCouplingLimit(std::uint16_t node, std::uint16_t curSum,
                     const std::vector<std::vector<std::uint16_t>>& connections,
-                    std::vector<int>& d, std::vector<bool>& visited);
+                    std::vector<std::uint16_t>& d, std::vector<bool>& visited);
 };