🔀 Merge pull request #75 from DVLab-NTU/clang-tidy/fix-readability-no…

…t-checked

Clang tidy/fix readability not checked

.clang-tidy

@@ -6,7 +6,9 @@ Checks: >
   -cppcoreguidelines-avoid-magic-numbers,
   -cppcoreguidelines-owning-memory,
   -cppcoreguidelines-non-private-member-variables-in-classes,
-  performance-noexcept-*,
+  bugprone-assert-side-effect,
+  performance-*,
+  performance-move-const-arg,
   modernize-use-auto,
   misc-const-correctness,
   misc-non-copyable-objects,
@@ -17,9 +19,18 @@ Checks: >
   misc-uniqueptr-reset-release,
   misc-unused-*,
   misc-use-anonymous-namespace,
-  bugprone-assert-side-effect,
-  performance-*
-  readability-*
+  readability-*,
+  -readability-implicit-bool-conversion,
+  -readability-redundant-string-init,
+  -readability-qualified-auto,
+  -readability-function-cognitive-complexity,
+  -readability-else-after-return,
+  -readability-convert-member-functions-to-static,
+  -readability-uppercase-literal-suffix,
+  -readability-isolate-declaration,
+  -readability-braces-around-statements,
+  -readability-magic-numbers,
+  -readability-identifier-length,
 WarningsAsErrors: ""
 HeaderFilterRegex: ".*"
 AnalyzeTemporaryDtors: false

src/argparse/arg_def.hpp

@@ -15,7 +15,7 @@
 namespace dvlab::argparse {
 
 namespace detail {
-struct heterogeneous_string_hash {
+struct HeterogeneousStringHash {
     using is_transparent = void;
     [[nodiscard]] size_t operator()(std::string_view str) const noexcept { return std::hash<std::string_view>{}(str); }
     [[nodiscard]] size_t operator()(std::string const& str) const noexcept { return std::hash<std::string>{}(str); }

src/argparse/arg_parser.hpp

@@ -37,7 +37,7 @@ struct ArgumentParserConfig {
 class SubParsers {
 private:
     struct SubParsersImpl;
-    using MapType = dvlab::utils::ordered_hashmap<std::string, ArgumentParser, detail::heterogeneous_string_hash, std::equal_to<>>;
+    using MapType = dvlab::utils::ordered_hashmap<std::string, ArgumentParser, detail::HeterogeneousStringHash, std::equal_to<>>;
     std::shared_ptr<SubParsersImpl> _pimpl;
 
 public:
@@ -180,9 +180,9 @@ class ArgumentParser {
     friend std::string detail::styled_parser_name(ArgumentParser const& parser);
     friend std::string detail::styled_parser_name_trace(ArgumentParser const& parser);
     struct ArgumentParserImpl {
-        dvlab::utils::ordered_hashmap<std::string, Argument, detail::heterogeneous_string_hash, std::equal_to<>> arguments;
-        std::unordered_map<std::string, std::string, detail::heterogeneous_string_hash, std::equal_to<>> alias_forward_map;
-        std::unordered_multimap<std::string, std::string, detail::heterogeneous_string_hash, std::equal_to<>> alias_reverse_map;
+        dvlab::utils::ordered_hashmap<std::string, Argument, detail::HeterogeneousStringHash, std::equal_to<>> arguments;
+        std::unordered_map<std::string, std::string, detail::HeterogeneousStringHash, std::equal_to<>> alias_forward_map;
+        std::unordered_multimap<std::string, std::string, detail::HeterogeneousStringHash, std::equal_to<>> alias_reverse_map;
         std::string option_prefixes = "-";
         std::vector<Token> tokens;
         std::unordered_map<std::string, std::string> dests;

src/argparse/arg_type.hpp

@@ -117,8 +117,8 @@ class ArgType {
     std::optional<T> _default_value = std::nullopt;
 
     std::string _name;
-    std::string _help                        = "";
-    std::string _metavar                     = "";
+    std::string _help;
+    std::string _metavar;
     std::optional<std::string> _usage        = std::nullopt;
     ActionCallbackType _action_callback      = nullptr;
     std::vector<ConstraintType> _constraints = {};

src/cli/cli.cpp

@@ -235,7 +235,7 @@ void dvlab::CommandLineInterface::sigint_handler(int signum) {
 
 std::optional<std::string> CommandLineInterface::_dequote(std::string_view str) const {
     std::string result;
-    using parse_state = CommandLineInterface::parse_state;
+    using parse_state = CommandLineInterface::ParseState;
     parse_state state = parse_state::normal;
     for (auto&& [i, ch] : str | tl::views::enumerate) {
         switch (state) {
@@ -280,8 +280,8 @@ std::optional<std::string> CommandLineInterface::_dequote(std::string_view str)
  * @return true
  * @return false
  */
-bool CommandLineInterface::_should_be_escaped(char ch, dvlab::CommandLineInterface::parse_state state) const {
-    using parse_state = dvlab::CommandLineInterface::parse_state;
+bool CommandLineInterface::_should_be_escaped(char ch, dvlab::CommandLineInterface::ParseState state) const {
+    using parse_state = dvlab::CommandLineInterface::ParseState;
     switch (state) {
         case parse_state::normal:
             return false;

src/cli/cli.hpp

@@ -29,7 +29,7 @@
 namespace dvlab {
 
 namespace detail {
-struct heterogeneous_string_hash {
+struct HeterogenousStringHash {
     using is_transparent = void;
 
     [[nodiscard]] size_t operator()(std::string_view str) const noexcept { return std::hash<std::string_view>{}(str); }
@@ -99,7 +99,7 @@ class CommandLineInterface {
     static constexpr size_t read_buf_size = 65536;
     static constexpr size_t page_offset   = 10;
 
-    using CmdMap = std::unordered_map<std::string, std::unique_ptr<dvlab::Command>, detail::heterogeneous_string_hash, std::equal_to<>>;
+    using CmdMap = std::unordered_map<std::string, std::unique_ptr<dvlab::Command>, detail::HeterogenousStringHash, std::equal_to<>>;
 
 public:
     /**
@@ -127,7 +127,7 @@ class CommandLineInterface {
     bool add_variables_from_dofiles(std::filesystem::path const& filepath, std::span<std::string const> arguments);
 
     void sigint_handler(int signum);
-    bool stop_requested() const { return _command_threads.size() && _command_threads.top().get_stop_token().stop_requested(); }
+    bool stop_requested() const { return !_command_threads.empty() && _command_threads.top().get_stop_token().stop_requested(); }
 
     // printing functions
     void list_all_commands() const;
@@ -158,7 +158,7 @@ class CommandLineInterface {
     constexpr static std::string_view double_quote_special_chars = "\\$";        // The characters that are identified as special characters when parsing inside double quotes
     constexpr static std::string_view special_chars              = "\\$\"\' ;";  // The characters that are identified as special characters when parsing
 
-    enum class parse_state {
+    enum class ParseState {
         normal,
         single_quote,
         double_quote,
@@ -206,8 +206,8 @@ class CommandLineInterface {
         std::vector<HistoryEntry> _history;
     };
     bool _echo = true;
-    std::unordered_map<std::string, std::string, detail::heterogeneous_string_hash, std::equal_to<>> _aliases;
-    std::unordered_map<std::string, std::string, detail::heterogeneous_string_hash, std::equal_to<>> _variables;  // stores the variables key-value pairs, e.g., $1, $INPUT_FILE, etc...
+    std::unordered_map<std::string, std::string, detail::HeterogenousStringHash, std::equal_to<>> _aliases;
+    std::unordered_map<std::string, std::string, detail::HeterogenousStringHash, std::equal_to<>> _variables;  // stores the variables key-value pairs, e.g., $1, $INPUT_FILE, etc...
 
     std::stack<jthread::jthread> _command_threads;
 
@@ -219,7 +219,7 @@ class CommandLineInterface {
     std::string _decode(std::string str) const;
     CmdExecResult _dispatch_command(dvlab::Command* cmd, std::vector<argparse::Token> options);
     bool _is_escaped(std::string_view str, size_t pos) const;
-    bool _should_be_escaped(char ch, dvlab::CommandLineInterface::parse_state state) const;
+    bool _should_be_escaped(char ch, dvlab::CommandLineInterface::ParseState state) const;
     // tab-related features features
     void _on_tab_pressed();
     // onTabPressed subroutines
@@ -230,7 +230,7 @@ class CommandLineInterface {
 
     // helper functions
     std::vector<std::string> _get_file_matches(std::filesystem::path const& filepath) const;
-    bool _autocomplete(std::string prefix_copy, std::vector<std::string> const& strs, parse_state state);
+    bool _autocomplete(std::string prefix_copy, std::vector<std::string> const& strs, ParseState state);
     void _print_as_table(std::vector<std::string> words) const;
 
     size_t _get_first_token_pos(std::string_view str, char token = ' ') const;

src/cli/cli_tab.cpp

@@ -165,7 +165,7 @@ dvlab::CommandLineInterface::TabActionResult dvlab::CommandLineInterface::_match
         return TabActionResult::no_op;
     }
 
-    if (_autocomplete(var_key, matching_variables, parse_state::normal /* does not matter */)) {
+    if (_autocomplete(var_key, matching_variables, ParseState::normal /* does not matter */)) {
         if (matching_variables.size() == 1 && is_brace) {
             _insert_char('}');
         }
@@ -184,13 +184,13 @@ dvlab::CommandLineInterface::TabActionResult dvlab::CommandLineInterface::_match
 dvlab::CommandLineInterface::TabActionResult dvlab::CommandLineInterface::_match_files(std::string_view str) {
     using namespace std::string_view_literals;
     std::optional<std::string> search_string;
-    parse_state state = parse_state::normal;
+    ParseState state = ParseState::normal;
     if (search_string = _dequote(str); search_string.has_value()) {
-        state = parse_state::normal;
+        state = ParseState::normal;
     } else if (search_string = _dequote(std::string{str} + '\"'); search_string.has_value()) {
-        state = parse_state::double_quote;
+        state = ParseState::double_quote;
     } else if (search_string = _dequote(std::string{str} + '\''); search_string.has_value()) {
-        state = parse_state::single_quote;
+        state = ParseState::single_quote;
     } else {
         spdlog::critical("unexpected dequote result!!");
         return TabActionResult::no_op;
@@ -226,8 +226,8 @@ dvlab::CommandLineInterface::TabActionResult dvlab::CommandLineInterface::_match
             if (fs::is_directory(dirname / files[0])) {
                 _insert_char('/');
             } else {
-                if (state == parse_state::single_quote) _insert_char('\'');
-                if (state == parse_state::double_quote) _insert_char('\"');
+                if (state == ParseState::single_quote) _insert_char('\'');
+                if (state == ParseState::double_quote) _insert_char('\"');
                 _insert_char(' ');
             }
         }
@@ -303,7 +303,7 @@ std::vector<std::string> dvlab::CommandLineInterface::_get_file_matches(fs::path
  * @return true if able to autocomplete
  * @return false if not
  */
-bool dvlab::CommandLineInterface::_autocomplete(std::string prefix_copy, std::vector<std::string> const& strs, parse_state state) {
+bool dvlab::CommandLineInterface::_autocomplete(std::string prefix_copy, std::vector<std::string> const& strs, ParseState state) {
     if (strs.size() == 1 && prefix_copy == strs[0]) return true;  // edge case: completing a file/dir name that is already complete
     bool trailing_backslash = false;
     if (prefix_copy.back() == '\\') {

src/convert/conversion_cmd.cpp

@@ -77,10 +77,10 @@ Command convert_from_qcir_cmd(
             auto to_type = parser.get<std::string>("to-type");
             if (to_type == "zx") {
                 spdlog::info("Converting to QCir {} to ZXGraph {}...", qcir_mgr.focused_id(), zxgraph_mgr.get_next_id());
-                auto const g = to_zxgraph(*qcir_mgr.get(), parser.get<size_t>("decomp-mode"));
+                auto graph = to_zxgraph(*qcir_mgr.get(), parser.get<size_t>("decomp-mode"));
 
-                if (g.has_value()) {
-                    zxgraph_mgr.add(zxgraph_mgr.get_next_id(), std::make_unique<qsyn::zx::ZXGraph>(std::move(g.value())));
+                if (graph.has_value()) {
+                    zxgraph_mgr.add(zxgraph_mgr.get_next_id(), std::make_unique<qsyn::zx::ZXGraph>(std::move(graph.value())));
 
                     zxgraph_mgr.get()->set_filename(qcir_mgr.get()->get_filename());
                     zxgraph_mgr.get()->add_procedures(qcir_mgr.get()->get_procedures());
@@ -201,7 +201,7 @@ Command convert_from_tensor_cmd(tensor::TensorMgr& tensor_mgr, QCirMgr& qcir_mgr
             auto to_type = parser.get<std::string>("to-type");
             if (to_type == "qcir") {
                 spdlog::info("Converting Tensor {} to QCir {}...", tensor_mgr.focused_id(), qcir_mgr.get_next_id());
-                auto const result = tensor::Decomposer{}.decompose(*tensor_mgr.get());
+                auto result = tensor::Decomposer{}.decompose(*tensor_mgr.get());
 
                 if (result) {
                     qcir_mgr.add(qcir_mgr.get_next_id(), std::make_unique<qcir::QCir>(std::move(*result)));
@@ -258,7 +258,7 @@ Command convert_from_tableau_cmd(experimental::TableauMgr& tableau_mgr, qcir::QC
                 });
 
                 spdlog::info("Converting to Tableau {} to QCir {}...", tableau_mgr.focused_id(), qcir_mgr.get_next_id());
-                auto const qcir = experimental::to_qcir(*tableau_mgr.get(), *clifford_strategy, *rotation_strategy);
+                auto qcir = experimental::to_qcir(*tableau_mgr.get(), *clifford_strategy, *rotation_strategy);
 
                 if (qcir.has_value()) {
                     qcir_mgr.add(qcir_mgr.get_next_id(), std::make_unique<qcir::QCir>(std::move(qcir.value())));

src/convert/qcir_to_tableau.cpp

@@ -41,13 +41,13 @@ Pauli to_pauli(qcir::GateRotationCategory const& category) {
     switch (category) {
         case qcir::GateRotationCategory::rz:
         case qcir::GateRotationCategory::pz:
-            return Pauli::Z;
+            return Pauli::z;
         case qcir::GateRotationCategory::rx:
         case qcir::GateRotationCategory::px:
-            return Pauli::X;
+            return Pauli::x;
         case qcir::GateRotationCategory::ry:
         case qcir::GateRotationCategory::py:
-            return Pauli::Y;
+            return Pauli::y;
         default:
             DVLAB_UNREACHABLE("Invalid rotation category");
     }
@@ -133,7 +133,7 @@ void implement_mcrz(Tableau& tableau, qcir::QCirGate const& gate, dvlab::Phase c
                 std::views::iota(0ul, tableau.n_qubits()) |
                 std::views::transform([&qubit_idx_vec, &comb_size, targ](auto i) -> Pauli {
                     // if i is in qubit_idx_range, return Z, otherwise I
-                    return (i == targ) || contains(qubit_idx_vec | std::views::take(comb_size), i) ? Pauli::Z : Pauli::I;
+                    return (i == targ) || contains(qubit_idx_vec | std::views::take(comb_size), i) ? Pauli::z : Pauli::i;
                 }) |
                 tl::to<std::vector>();
             last_rotation_group.push_back(PauliRotation(pauli_range.begin(), pauli_range.end(), is_neg ? -phase : phase));
@@ -155,7 +155,7 @@ void implement_mcpz(Tableau& tableau, qcir::QCirGate const& gate, dvlab::Phase c
             auto const pauli_range =
                 std::views::iota(0ul, tableau.n_qubits()) |
                 std::views::transform([&qubit_idx_vec, &comb_size](auto i) -> Pauli {
-                    return contains(qubit_idx_vec | std::views::take(comb_size), i) ? Pauli::Z : Pauli::I;
+                    return contains(qubit_idx_vec | std::views::take(comb_size), i) ? Pauli::z : Pauli::i;
                 }) |
                 tl::to<std::vector>();
             last_rotation_group.push_back(PauliRotation(pauli_range.begin(), pauli_range.end(), is_neg ? -phase : phase));
@@ -173,9 +173,9 @@ void implement_rotation_gate(Tableau& tableau, qcir::QCirGate const& gate) {
 
     auto const targ = gsl::narrow<size_t>(gate.get_qubits().back()._qubit);
     // convert rotation plane first
-    if (pauli == Pauli::X) {
+    if (pauli == Pauli::x) {
         tableau.h(targ);
-    } else if (pauli == Pauli::Y) {
+    } else if (pauli == Pauli::y) {
         tableau.v(targ);
     }
 
@@ -190,9 +190,9 @@ void implement_rotation_gate(Tableau& tableau, qcir::QCirGate const& gate) {
     }
 
     // restore rotation plane
-    if (pauli == Pauli::X) {
+    if (pauli == Pauli::x) {
         tableau.h(targ);
-    } else if (pauli == Pauli::Y) {
+    } else if (pauli == Pauli::y) {
         tableau.vdg(targ);
     }
 }

src/convert/tableau_to_qcir.cpp

@@ -68,7 +68,7 @@ void add_clifford_gate(qcir::QCir& qcir, CliffordOperator const& op) {
  * @param clifford - pass by value on purpose
  * @return std::optional<qcir::QCir>
  */
-std::optional<qcir::QCir> to_qcir(StabilizerTableau clifford, StabilizerTableauSynthesisStrategy const& strategy) {
+std::optional<qcir::QCir> to_qcir(StabilizerTableau const& clifford, StabilizerTableauSynthesisStrategy const& strategy) {
     qcir::QCir qcir{clifford.n_qubits()};
     for (auto const& op : extract_clifford_operators(clifford, strategy)) {
         add_clifford_gate(qcir, op);

src/convert/tableau_to_qcir.hpp

@@ -31,7 +31,7 @@ struct TParPauliRotationsSynthesisStrategy : public PauliRotationsSynthesisStrat
 };
 
 std::optional<qcir::QCir> to_qcir(
-    StabilizerTableau clifford,
+    StabilizerTableau const& clifford,
     StabilizerTableauSynthesisStrategy const& strategy);
 std::optional<qcir::QCir> to_qcir(
     std::vector<PauliRotation> const& rotations,