fix: resolve compiler warnings (graph-indexes)

Resolve -Wall -Wextra -Wshadow warnings in graph index files:
- Rename constructor/function parameters that shadow member variables
- Add explicit casts for sign comparison warnings
- Add [[maybe_unused]] attributes where appropriate
- Fix unused parameter warnings

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: maxwbuckley

faiss/IndexBinaryHNSW.cpp

@@ -62,7 +62,7 @@ void hnsw_add_vertices(
     }
 
     std::vector<omp_lock_t> locks(ntotal);
-    for (int i = 0; i < ntotal; i++) {
+    for (size_t i = 0; i < ntotal; i++) {
         omp_init_lock(&locks[i]);
     }
 
@@ -73,23 +73,23 @@ void hnsw_add_vertices(
     { // make buckets with vectors of the same level
 
         // build histogram
-        for (int i = 0; i < n; i++) {
+        for (size_t i = 0; i < n; i++) {
             HNSW::storage_idx_t pt_id = i + n0;
             int pt_level = hnsw.levels[pt_id] - 1;
-            while (pt_level >= hist.size()) {
+            while (pt_level >= static_cast<int>(hist.size())) {
                 hist.push_back(0);
             }
             hist[pt_level]++;
         }
 
         // accumulate
         std::vector<int> offsets(hist.size() + 1, 0);
-        for (int i = 0; i < hist.size() - 1; i++) {
+        for (size_t i = 0; i < hist.size() - 1; i++) {
             offsets[i + 1] = offsets[i] + hist[i];
         }
 
         // bucket sort
-        for (int i = 0; i < n; i++) {
+        for (size_t i = 0; i < n; i++) {
             HNSW::storage_idx_t pt_id = i + n0;
             int pt_level = hnsw.levels[pt_id] - 1;
             order[offsets[pt_level]++] = pt_id;
@@ -101,7 +101,7 @@ void hnsw_add_vertices(
 
         int i1 = n;
 
-        for (int pt_level = hist.size() - 1;
+        for (int pt_level = static_cast<int>(hist.size()) - 1;
              pt_level >= int(!index_hnsw.init_level0);
              pt_level--) {
             int i0 = i1 - hist[pt_level];
@@ -157,7 +157,7 @@ void hnsw_add_vertices(
         printf("Done in %.3f ms\n", getmillisecs() - t0);
     }
 
-    for (int i = 0; i < ntotal; i++) {
+    for (size_t i = 0; i < ntotal; i++) {
         omp_destroy_lock(&locks[i]);
     }
 }
@@ -172,19 +172,19 @@ IndexBinaryHNSW::IndexBinaryHNSW() {
     is_trained = true;
 }
 
-IndexBinaryHNSW::IndexBinaryHNSW(int d, int M)
-        : IndexBinary(d),
+IndexBinaryHNSW::IndexBinaryHNSW(int d_, int M)
+        : IndexBinary(d_),
           hnsw(M),
           own_fields(true),
-          storage(new IndexBinaryFlat(d)) {
+          storage(new IndexBinaryFlat(d_)) {
     is_trained = true;
 }
 
-IndexBinaryHNSW::IndexBinaryHNSW(IndexBinary* storage, int M)
-        : IndexBinary(storage->d),
+IndexBinaryHNSW::IndexBinaryHNSW(IndexBinary* storage_, int M)
+        : IndexBinary(storage_->d),
           hnsw(M),
           own_fields(false),
-          storage(storage) {
+          storage(storage_) {
     is_trained = true;
 }
 
@@ -242,7 +242,7 @@ void IndexBinaryHNSW::search(
     }
 
 #pragma omp parallel for
-    for (int i = 0; i < n * k; ++i) {
+    for (idx_t i = 0; i < n * k; ++i) {
         distances[i] = std::round(distances_f[i]);
     }
 }
@@ -253,7 +253,13 @@ void IndexBinaryHNSW::add(idx_t n, const uint8_t* x) {
     storage->add(n, x);
     ntotal = storage->ntotal;
 
-    hnsw_add_vertices(*this, n0, n, x, verbose, hnsw.levels.size() == ntotal);
+    hnsw_add_vertices(
+            *this,
+            n0,
+            n,
+            x,
+            verbose,
+            hnsw.levels.size() == static_cast<size_t>(ntotal));
 }
 
 void IndexBinaryHNSW::reset() {
@@ -330,8 +336,8 @@ IndexBinaryHNSWCagra::IndexBinaryHNSWCagra() : IndexBinaryHNSW() {
     storage = nullptr;
 }
 
-IndexBinaryHNSWCagra::IndexBinaryHNSWCagra(int d, int M)
-        : IndexBinaryHNSW(d, M) {
+IndexBinaryHNSWCagra::IndexBinaryHNSWCagra(int d_, int M)
+        : IndexBinaryHNSW(d_, M) {
     init_level0 = true;
     keep_max_size_level0 = true;
 }
@@ -415,7 +421,7 @@ void IndexBinaryHNSWCagra::search(
         }
 
 #pragma omp parallel for
-        for (int i = 0; i < n * k; ++i) {
+        for (idx_t i = 0; i < n * k; ++i) {
             distances[i] = std::round(distances_f[i]);
         }
     }

faiss/IndexHNSW.cpp

@@ -83,7 +83,7 @@ void hnsw_add_vertices(
     }
 
     std::vector<omp_lock_t> locks(ntotal);
-    for (int i = 0; i < ntotal; i++) {
+    for (size_t i = 0; i < ntotal; i++) {
         omp_init_lock(&locks[i]);
     }
 
@@ -94,23 +94,23 @@ void hnsw_add_vertices(
     { // make buckets with vectors of the same level
 
         // build histogram
-        for (int i = 0; i < n; i++) {
+        for (size_t i = 0; i < n; i++) {
             storage_idx_t pt_id = i + n0;
             int pt_level = hnsw.levels[pt_id] - 1;
-            while (pt_level >= hist.size()) {
+            while (pt_level >= static_cast<int>(hist.size())) {
                 hist.push_back(0);
             }
             hist[pt_level]++;
         }
 
         // accumulate
         std::vector<int> offsets(hist.size() + 1, 0);
-        for (int i = 0; i < hist.size() - 1; i++) {
+        for (size_t i = 0; i < hist.size() - 1; i++) {
             offsets[i + 1] = offsets[i] + hist[i];
         }
 
         // bucket sort
-        for (int i = 0; i < n; i++) {
+        for (size_t i = 0; i < n; i++) {
             storage_idx_t pt_id = i + n0;
             int pt_level = hnsw.levels[pt_id] - 1;
             order[offsets[pt_level]++] = pt_id;
@@ -125,7 +125,7 @@ void hnsw_add_vertices(
 
         int i1 = n;
 
-        for (int pt_level = hist.size() - 1;
+        for (int pt_level = static_cast<int>(hist.size()) - 1;
              pt_level >= int(!index_hnsw.init_level0);
              pt_level--) {
             int i0 = i1 - hist[pt_level];
@@ -200,7 +200,7 @@ void hnsw_add_vertices(
         printf("Done in %.3f ms\n", getmillisecs() - t0);
     }
 
-    for (int i = 0; i < ntotal; i++) {
+    for (size_t i = 0; i < ntotal; i++) {
         omp_destroy_lock(&locks[i]);
     }
 }
@@ -211,11 +211,13 @@ void hnsw_add_vertices(
  * IndexHNSW implementation
  **************************************************************/
 
-IndexHNSW::IndexHNSW(int d, int M, MetricType metric)
-        : Index(d, metric), hnsw(M) {}
+IndexHNSW::IndexHNSW(int d_in, int M, MetricType metric)
+        : Index(d_in, metric), hnsw(M) {}
 
-IndexHNSW::IndexHNSW(Index* storage, int M)
-        : Index(storage->d, storage->metric_type), hnsw(M), storage(storage) {
+IndexHNSW::IndexHNSW(Index* storage_in, int M)
+        : Index(storage_in->d, storage_in->metric_type),
+          hnsw(M),
+          storage(storage_in) {
     metric_arg = storage->metric_arg;
 }
 
@@ -309,7 +311,7 @@ void IndexHNSW::search(
 
     if (is_similarity_metric(this->metric_type)) {
         // we need to revert the negated distances
-        for (size_t i = 0; i < k * n; i++) {
+        for (idx_t i = 0; i < k * n; i++) {
             distances[i] = -distances[i];
         }
     }
@@ -351,7 +353,13 @@ void IndexHNSW::add(idx_t n, const float* x) {
     storage->add(n, x);
     ntotal = storage->ntotal;
 
-    hnsw_add_vertices(*this, n0, n, x, verbose, hnsw.levels.size() == ntotal);
+    hnsw_add_vertices(
+            *this,
+            n0,
+            n,
+            x,
+            verbose,
+            hnsw.levels.size() == static_cast<size_t>(ntotal));
 }
 
 void IndexHNSW::reset() {
@@ -427,7 +435,7 @@ void IndexHNSW::search_level_0(
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(nprobe > 0);
 
-    storage_idx_t ntotal = hnsw.levels.size();
+    storage_idx_t hnsw_ntotal = hnsw.levels.size();
 
     using RH = HeapBlockResultHandler<HNSW::C>;
     RH bres(n, distances, labels, k);
@@ -437,7 +445,7 @@ void IndexHNSW::search_level_0(
         std::unique_ptr<DistanceComputer> qdis(
                 storage_distance_computer(storage));
         HNSWStats search_stats;
-        VisitedTable vt(ntotal, hnsw.use_visited_hashset);
+        VisitedTable vt(hnsw_ntotal, hnsw.use_visited_hashset);
         RH::SingleResultHandler res(bres);
 
 #pragma omp for
@@ -487,7 +495,7 @@ void IndexHNSW::init_level_0_from_knngraph(
 
         std::priority_queue<NodeDistFarther> initial_list;
 
-        for (size_t j = 0; j < k; j++) {
+        for (int j = 0; j < k; j++) {
             int v1 = I[i * k + j];
             if (v1 == i) {
                 continue;
@@ -519,7 +527,7 @@ void IndexHNSW::init_level_0_from_entry_points(
         const storage_idx_t* points,
         const storage_idx_t* nearests) {
     std::vector<omp_lock_t> locks(ntotal);
-    for (int i = 0; i < ntotal; i++) {
+    for (idx_t i = 0; i < ntotal; i++) {
         omp_init_lock(&locks[i]);
     }
 
@@ -551,7 +559,7 @@ void IndexHNSW::init_level_0_from_entry_points(
         printf("\n");
     }
 
-    for (int i = 0; i < ntotal; i++) {
+    for (idx_t i = 0; i < ntotal; i++) {
         omp_destroy_lock(&locks[i]);
     }
 }
@@ -595,7 +603,7 @@ void IndexHNSW::link_singletons() {
 
     std::vector<bool> seen(ntotal);
 
-    for (size_t i = 0; i < ntotal; i++) {
+    for (idx_t i = 0; i < ntotal; i++) {
         size_t begin, end;
         hnsw.neighbor_range(i, 0, &begin, &end);
         for (size_t j = begin; j < end; j++) {
@@ -624,7 +632,7 @@ void IndexHNSW::link_singletons() {
            n_sing_l1);
 
     std::vector<float> recons(singletons.size() * d);
-    for (int i = 0; i < singletons.size(); i++) {
+    for (size_t i = 0; i < singletons.size(); i++) {
         FAISS_ASSERT(false); // not implemented
     }
 }
@@ -649,10 +657,10 @@ IndexHNSWFlat::IndexHNSWFlat() {
     is_trained = true;
 }
 
-IndexHNSWFlat::IndexHNSWFlat(int d, int M, MetricType metric)
+IndexHNSWFlat::IndexHNSWFlat(int d_in, int M, MetricType metric)
         : IndexHNSW(
-                  (metric == METRIC_L2) ? new IndexFlatL2(d)
-                                        : new IndexFlat(d, metric),
+                  (metric == METRIC_L2) ? new IndexFlatL2(d_in)
+                                        : new IndexFlat(d_in, metric),
                   M) {
     own_fields = true;
     is_trained = true;
@@ -666,14 +674,14 @@ IndexHNSWFlatPanorama::IndexHNSWFlatPanorama()
         : IndexHNSWFlat(), cum_sums(), pano(0, 1, 1), num_panorama_levels(0) {}
 
 IndexHNSWFlatPanorama::IndexHNSWFlatPanorama(
-        int d,
+        int d_in,
         int M,
-        int num_panorama_levels,
+        int num_panorama_levels_in,
         MetricType metric)
-        : IndexHNSWFlat(d, M, metric),
+        : IndexHNSWFlat(d_in, M, metric),
           cum_sums(),
-          pano(d * sizeof(float), num_panorama_levels, 1),
-          num_panorama_levels(num_panorama_levels) {
+          pano(d_in * sizeof(float), num_panorama_levels_in, 1),
+          num_panorama_levels(num_panorama_levels_in) {
     // For now, we only support L2 distance.
     // Supporting dot product and cosine distance is a trivial addition
     // left for future work.
@@ -718,12 +726,12 @@ void IndexHNSWFlatPanorama::permute_entries(const idx_t* perm) {
 IndexHNSWPQ::IndexHNSWPQ() = default;
 
 IndexHNSWPQ::IndexHNSWPQ(
-        int d,
+        int d_in,
         int pq_m,
         int M,
         int pq_nbits,
         MetricType metric)
-        : IndexHNSW(new IndexPQ(d, pq_m, pq_nbits, metric), M) {
+        : IndexHNSW(new IndexPQ(d_in, pq_m, pq_nbits, metric), M) {
     own_fields = true;
     is_trained = false;
 }
@@ -738,11 +746,11 @@ void IndexHNSWPQ::train(idx_t n, const float* x) {
  **************************************************************/
 
 IndexHNSWSQ::IndexHNSWSQ(
-        int d,
+        int d_in,
         ScalarQuantizer::QuantizerType qtype,
         int M,
         MetricType metric)
-        : IndexHNSW(new IndexScalarQuantizer(d, qtype, metric), M) {
+        : IndexHNSW(new IndexScalarQuantizer(d_in, qtype, metric), M) {
     is_trained = this->storage->is_trained;
     own_fields = true;
 }
@@ -900,7 +908,7 @@ void IndexHNSW2Level::search(
                     size_t list_length = index_ivfpq->get_list_size(key);
                     const idx_t* ids = index_ivfpq->invlists->get_ids(key);
 
-                    for (int jj = 0; jj < list_length; jj++) {
+                    for (size_t jj = 0; jj < list_length; jj++) {
                         vt.set(ids[jj]);
                     }
                 }
@@ -976,11 +984,11 @@ IndexHNSWCagra::IndexHNSWCagra() {
 }
 
 IndexHNSWCagra::IndexHNSWCagra(
-        int d,
+        int d_in,
         int M,
         MetricType metric,
         NumericType numeric_type)
-        : IndexHNSW(d, M, metric) {
+        : IndexHNSW(d_in, M, metric) {
     FAISS_THROW_IF_NOT_MSG(
             ((metric == METRIC_L2) || (metric == METRIC_INNER_PRODUCT)),
             "unsupported metric type for IndexHNSWCagra");