cppcoreguidelines-pro-type-member-init (#349)

Author: elshize

.clang-tidy

@@ -12,13 +12,16 @@ Checks: |
     readability-else-after-return,
     readability-implicit-bool-conversion,
     readability-uppercase-literal-suffix,
+    readability-container-size-empty,
     modernize-loop-convert,
     modernize-use-equals-default,
     modernize-use-using,
     cppcoreguidelines-special-member-functions,
+    cppcoreguidelines-pro-type-member-init,
     -hicpp-signed-bitwise,
     -modernize-use-trailing-return-type,
     -fuchsia-overloaded-operator,
     -fuchsia-default-arguments-calls,
     -fuchsia-trailing-return,
-    -llvm-header-guard
+    -llvm-header-guard,
+    -google-runtime-references

include/pisa/bit_vector.hpp

@@ -352,7 +352,7 @@ class bit_vector {
     mapper::mappable_vector<uint64_t> const& data() const { return m_bits; }
 
     struct enumerator {
-        enumerator() : m_bv(0), m_pos(uint64_t(-1)) {}
+        enumerator() = default;
 
         enumerator(bit_vector const& bv, size_t pos) : m_bv(&bv), m_pos(pos), m_buf(0), m_avail(0)
         {
@@ -416,10 +416,10 @@ class bit_vector {
             m_avail = 64;
         }
 
-        bit_vector const* m_bv;
-        size_t m_pos;
-        uint64_t m_buf;
-        size_t m_avail;
+        bit_vector const* m_bv{0};
+        std::uint64_t m_pos{std::numeric_limits<std::uint64_t>::max()};
+        std::uint64_t m_buf{0};
+        std::uint64_t m_avail{0};
     };
 
     struct unary_enumerator {
@@ -510,7 +510,7 @@ class bit_vector {
     };
 
   protected:
-    size_t m_size;
+    size_t m_size{0};
     mapper::mappable_vector<uint64_t> m_bits;
 };
 

include/pisa/block_freq_index.hpp

@@ -11,7 +11,7 @@ namespace pisa {
 template <typename BlockCodec, bool Profile = false>
 class block_freq_index {
   public:
-    block_freq_index() : m_size(0) {}
+    block_freq_index() = default;
 
     class builder {
       public:
@@ -126,8 +126,8 @@ class block_freq_index {
 
   private:
     global_parameters m_params;
-    size_t m_size;
-    size_t m_num_docs;
+    size_t m_size{0};
+    size_t m_num_docs{0};
     bit_vector m_endpoints;
     mapper::mappable_vector<uint8_t> m_lists;
 };

include/pisa/block_posting_list.hpp

@@ -79,13 +79,8 @@ struct block_posting_list {
 
     class document_enumerator {
       public:
-        document_enumerator(
-            uint8_t const* data,
-            uint64_t universe,
-            size_t term_id = 0)
-            : m_n(0)  // just to silence warnings
-              ,
-              m_base(TightVariableByte::decode(data, &m_n, 1)),
+        document_enumerator(uint8_t const* data, uint64_t universe, size_t term_id = 0)
+            : m_base(TightVariableByte::decode(data, &m_n, 1)),
               m_blocks(ceil_div(m_n, BlockCodec::block_size)),
               m_block_maxs(m_base),
               m_block_endpoints(m_block_maxs + 4 * m_blocks),
@@ -300,22 +295,22 @@ struct block_posting_list {
             }
         }
 
-        uint32_t m_n;
+        uint32_t m_n{0};
         uint8_t const* m_base;
         uint32_t m_blocks;
         uint8_t const* m_block_maxs;
         uint8_t const* m_block_endpoints;
         uint8_t const* m_blocks_data;
         uint64_t m_universe;
 
-        uint32_t m_cur_block;
-        uint32_t m_pos_in_block;
-        uint32_t m_cur_block_max;
-        uint32_t m_cur_block_size;
-        uint32_t m_cur_docid;
+        uint32_t m_cur_block{0};
+        uint32_t m_pos_in_block{0};
+        uint32_t m_cur_block_max{0};
+        uint32_t m_cur_block_size{0};
+        uint32_t m_cur_docid{0};
 
-        uint8_t const* m_freqs_block_data;
-        bool m_freqs_decoded;
+        uint8_t const* m_freqs_block_data{nullptr};
+        bool m_freqs_decoded{false};
 
         std::vector<uint32_t> m_docs_buf;
         std::vector<uint32_t> m_freqs_buf;

include/pisa/codec/block_codecs.hpp

@@ -170,7 +170,7 @@ struct interpolative_block {
 
 struct optpfor_block {
     struct codec_type: FastPForLib::OPTPFor<4, FastPForLib::Simple16<false>> {
-        uint8_t const* force_b;
+        uint8_t const* force_b{nullptr};
 
         uint32_t findBestB(const uint32_t* in, uint32_t len)
         {

include/pisa/codec/compact_elias_fano.hpp

@@ -386,11 +386,11 @@ struct compact_elias_fano {
 
         inline uint64_t pointer1(uint64_t i) const { return pointer(m_of.pointers1_offset, i); }
 
-        bit_vector const* m_bv;
-        offsets m_of;
+        bit_vector const* m_bv{nullptr};
+        offsets m_of{};
 
-        uint64_t m_position;
-        uint64_t m_value;
+        uint64_t m_position{0};
+        uint64_t m_value{0};
         bit_vector::unary_enumerator m_high_enumerator;
     };
 };

include/pisa/configuration.hpp

@@ -17,23 +17,21 @@ class configuration {
         return instance;
     }
 
-    size_t quantization_bits;
-    bool heuristic_greedy;
+    size_t quantization_bits{8};
+    bool heuristic_greedy{false};
 
   private:
     configuration()
     {
-        fillvar("PISA_HEURISTIC_GREEDY", heuristic_greedy, false);
-        fillvar("PISA_QUANTIZTION_BITS", quantization_bits, 8);
+        fillvar("PISA_HEURISTIC_GREEDY", heuristic_greedy);
+        fillvar("PISA_QUANTIZTION_BITS", quantization_bits);
     }
 
-    template <typename T, typename T2>
-    void fillvar(const char* envvar, T& var, T2 def)
+    template <typename T>
+    void fillvar(const char* envvar, T& var)
     {
         const char* val = std::getenv(envvar);
-        if (!val || !strlen(val)) {
-            var = def;
-        } else {
+        if (val && strlen(val)) {
             var = boost::lexical_cast<T>(val);
         }
     }

include/pisa/cursor/block_max_scored_cursor.hpp

@@ -12,6 +12,8 @@ struct block_max_scored_cursor {
     using enum_type = typename Index::document_enumerator;
     using wdata_enum = typename WandType::wand_data_enumerator;
 
+    block_max_scored_cursor() = delete;
+
     enum_type docs_enum;
     wdata_enum w;
     float q_weight;
@@ -40,4 +42,4 @@ template <typename Index, typename WandType, typename Scorer>
     return cursors;
 }
 
-}  // namespace pisa
+}  // namespace pisa

include/pisa/cursor/max_scored_cursor.hpp

@@ -10,6 +10,7 @@ namespace pisa {
 template <typename Index>
 struct max_scored_cursor {
     using enum_type = typename Index::document_enumerator;
+    max_scored_cursor() = delete;
     enum_type docs_enum;
     float q_weight;
     term_scorer_t scorer;

include/pisa/cursor/scored_cursor.hpp

@@ -10,6 +10,7 @@ namespace pisa {
 template <typename Index>
 struct scored_cursor {
     using enum_type = typename Index::document_enumerator;
+    scored_cursor() = delete;
     enum_type docs_enum;
     float q_weight;
     term_scorer_t scorer;

include/pisa/dec_time_prediction.hpp

@@ -51,7 +51,7 @@ namespace pisa { namespace time_prediction {
 
     class feature_vector {
       public:
-        feature_vector() { std::fill(m_features.begin(), m_features.end(), 0); }
+        feature_vector() = default;
 
         float& operator[](feature_type f) { return m_features[(size_t)f]; }
         float const& operator[](feature_type f) const { return m_features[(size_t)f]; }
@@ -66,12 +66,12 @@ namespace pisa { namespace time_prediction {
         }
 
       protected:
-        std::array<float, num_features> m_features;
+        std::array<float, num_features> m_features{};
     };
 
     class predictor: public feature_vector {
       public:
-        predictor() : m_bias(0) {}
+        predictor() = default;
 
         explicit predictor(std::vector<std::pair<std::string, float>> const& values)
         {
@@ -98,7 +98,7 @@ namespace pisa { namespace time_prediction {
         }
 
       protected:
-        float m_bias;
+        float m_bias{0.0};
     };
 
     inline void values_statistics(std::vector<uint32_t> values, feature_vector& f)

include/pisa/freq_index.hpp

@@ -119,8 +119,8 @@ class freq_index {
             reset();
         }
 
-        uint64_t m_cur_pos;
-        uint64_t m_cur_docid;
+        uint64_t m_cur_pos{0};
+        uint64_t m_cur_docid{0};
         typename DocsSequence::enumerator m_docs_enum;
         typename FreqsSequence::enumerator m_freqs_enum;
     };

include/pisa/invert.hpp

@@ -320,7 +320,7 @@ namespace invert {
                 spdlog::error(msg);
                 throw std::runtime_error(msg);
             }
-            if (dlist.size() == 0U) {
+            if (dlist.empty()) {
                 auto msg = fmt::format("Posting list must be non-empty (term {})", term_id);
                 spdlog::error(msg);
                 throw std::runtime_error(msg);

include/pisa/mappable/mapper.hpp

@@ -275,7 +275,7 @@ namespace pisa { namespace mapper {
     {
         detail::sizeof_visitor sizer(true);
         sizer(val, friendly_name);
-        assert(sizer.size_tree()->children.size());
+        assert(not sizer.size_tree()->children.empty());
         return sizer.size_tree()->children[0];
     }
 

include/pisa/score_opt_partition.hpp

@@ -77,7 +77,7 @@ struct score_opt_partition {
             float v = std::get<1>(*end_it);
             sum += v;
 
-            while (max_queue.size() > 0 && max_queue.back() < std::get<1>(*end_it)) {
+            while (not max_queue.empty() && max_queue.back() < std::get<1>(*end_it)) {
                 max_queue.pop_back();
             }
 

include/pisa/sequence/indexed_sequence.hpp

@@ -138,7 +138,7 @@ struct indexed_sequence {
         }
 
       private:
-        index_type m_type;
+        index_type m_type{};
         boost::variant<compact_elias_fano::enumerator, compact_ranked_bitvector::enumerator, all_ones_sequence::enumerator>
             m_enumerator;
     };

include/pisa/sequence/partitioned_sequence.hpp

@@ -79,7 +79,7 @@ struct partitioned_sequence {
                 }
 
                 uint64_t upper_bound = value;
-                assert(cur_partition.size() > 0);
+                assert(not cur_partition.empty());
                 base_sequence_type::write(
                     bv_sequences,
                     cur_partition.begin(),
@@ -305,21 +305,21 @@ struct partitioned_sequence {
         }
 
         global_parameters m_params;
-        uint64_t m_partitions;
-        uint64_t m_endpoints_offset;
-        uint64_t m_endpoint_bits;
-        uint64_t m_sequences_offset;
-        uint64_t m_size;
-        uint64_t m_universe;
-
-        uint64_t m_position;
-        uint64_t m_cur_partition;
-        uint64_t m_cur_begin;
-        uint64_t m_cur_end;
-        uint64_t m_cur_base;
-        uint64_t m_cur_upper_bound;
-
-        bit_vector const* m_bv;
+        uint64_t m_partitions{0};
+        uint64_t m_endpoints_offset{0};
+        uint64_t m_endpoint_bits{0};
+        uint64_t m_sequences_offset{0};
+        uint64_t m_size{0};
+        uint64_t m_universe{0};
+
+        uint64_t m_position{0};
+        uint64_t m_cur_partition{0};
+        uint64_t m_cur_begin{0};
+        uint64_t m_cur_end{0};
+        uint64_t m_cur_base{0};
+        uint64_t m_cur_upper_bound{0};
+
+        bit_vector const* m_bv{nullptr};
         compact_elias_fano::enumerator m_sizes;
         compact_elias_fano::enumerator m_upper_bounds;
         base_sequence_enumerator m_partition_enum;

include/pisa/sequence/strict_sequence.hpp

@@ -146,7 +146,7 @@ struct strict_sequence {
         }
 
       private:
-        index_type m_type;
+        index_type m_type{};
         boost::variant<strict_elias_fano::enumerator, compact_ranked_bitvector::enumerator, all_ones_sequence::enumerator>
             m_enumerator;
     };

include/pisa/sequence/uniform_partitioned_sequence.hpp

@@ -73,7 +73,7 @@ struct uniform_partitioned_sequence {
                 assert((p == partitions - 1) || cur_partition.size() == partition_size);
 
                 uint64_t upper_bound = value;
-                assert(cur_partition.size() > 0);
+                assert(not cur_partition.empty());
                 base_sequence_type::write(
                     bv_sequences,
                     cur_partition.begin(),
@@ -284,21 +284,21 @@ struct uniform_partitioned_sequence {
         }
 
         global_parameters m_params;
-        uint64_t m_partitions;
-        uint64_t m_endpoints_offset;
-        uint64_t m_endpoint_bits;
-        uint64_t m_sequences_offset;
-        uint64_t m_size;
-        uint64_t m_universe;
-
-        uint64_t m_position;
-        uint64_t m_cur_partition;
-        uint64_t m_cur_begin;
-        uint64_t m_cur_end;
-        uint64_t m_cur_base;
-        uint64_t m_cur_upper_bound;
-
-        bit_vector const* m_bv;
+        uint64_t m_partitions{0};
+        uint64_t m_endpoints_offset{0};
+        uint64_t m_endpoint_bits{0};
+        uint64_t m_sequences_offset{0};
+        uint64_t m_size{0};
+        uint64_t m_universe{0};
+
+        uint64_t m_position{0};
+        uint64_t m_cur_partition{0};
+        uint64_t m_cur_begin{0};
+        uint64_t m_cur_end{0};
+        uint64_t m_cur_base{0};
+        uint64_t m_cur_upper_bound{0};
+
+        bit_vector const* m_bv{nullptr};
         compact_elias_fano::enumerator m_upper_bounds;
         base_sequence_enumerator m_partition_enum;
     };

include/pisa/sequence_collection.hpp

@@ -101,7 +101,7 @@ class sequence_collection {
 
   private:
     global_parameters m_params;
-    size_t m_size;
+    size_t m_size{0};
     bitvector_collection m_sequences;
 };
 }  // namespace pisa