fix: resolve compiler warnings (utils-distances)

Mechanical fixes for compiler warnings found with -Wall -Wextra -Wshadow.
No functional changes — only variable renames, unused parameter annotations,
signed/unsigned casts, and [[fallthrough]] attributes.

Part 6/13 of the compiler warnings cleanup (split from PR facebookresearch#4810).

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

Author: maxwbuckley

faiss/utils/Heap.cpp

@@ -17,15 +17,15 @@ namespace faiss {
 template <typename C>
 void HeapArray<C>::heapify() {
 #pragma omp parallel for
-    for (int64_t j = 0; j < nh; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(nh); j++) {
         heap_heapify<C>(k, val + j * k, ids + j * k);
     }
 }
 
 template <typename C>
 void HeapArray<C>::reorder() {
 #pragma omp parallel for
-    for (int64_t j = 0; j < nh; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(nh); j++) {
         heap_reorder<C>(k, val + j * k, ids + j * k);
     }
 }
@@ -37,7 +37,7 @@ void HeapArray<C>::addn(size_t nj, const T* vin, TI j0, size_t i0, int64_t ni) {
     }
     assert(i0 >= 0 && i0 + ni <= nh);
 #pragma omp parallel for if (ni * nj > 100000)
-    for (int64_t i = i0; i < i0 + ni; i++) {
+    for (int64_t i = i0; i < static_cast<int64_t>(i0) + ni; i++) {
         T* __restrict simi = get_val(i);
         TI* __restrict idxi = get_ids(i);
         const T* ip_line = vin + (i - i0) * nj;
@@ -68,7 +68,7 @@ void HeapArray<C>::addn_with_ids(
     }
     assert(i0 >= 0 && i0 + ni <= nh);
 #pragma omp parallel for if (ni * nj > 100000)
-    for (int64_t i = i0; i < i0 + ni; i++) {
+    for (int64_t i = i0; i < static_cast<int64_t>(i0) + ni; i++) {
         T* __restrict simi = get_val(i);
         TI* __restrict idxi = get_ids(i);
         const T* ip_line = vin + (i - i0) * nj;
@@ -96,7 +96,7 @@ void HeapArray<C>::addn_query_subset_with_ids(
         id_stride = nj;
     }
 #pragma omp parallel for if (nsubset * nj > 100000)
-    for (int64_t si = 0; si < nsubset; si++) {
+    for (int64_t si = 0; si < static_cast<int64_t>(nsubset); si++) {
         TI i = subset[si];
         T* __restrict simi = get_val(i);
         TI* __restrict idxi = get_ids(i);
@@ -115,7 +115,7 @@ void HeapArray<C>::addn_query_subset_with_ids(
 template <typename C>
 void HeapArray<C>::per_line_extrema(T* out_val, TI* out_ids) const {
 #pragma omp parallel for if (nh * k > 100000)
-    for (int64_t j = 0; j < nh; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(nh); j++) {
         int64_t imin = -1;
         typename C::T xval = C::Crev::neutral();
         const typename C::T* x_ = val + j * k;
@@ -187,15 +187,15 @@ void merge_knn_results(
         std::vector<distance_t> buf2(nshard);
         distance_t* heap_vals = buf2.data();
 #pragma omp for
-        for (long i = 0; i < n; i++) {
+        for (long i = 0; i < static_cast<long>(n); i++) {
             // the heap maps values to the shard where they are
             // produced.
             const distance_t* D_in = all_distances + i * k;
             const idx_t* I_in = all_labels + i * k;
             int heap_size = 0;
 
             // push the first element of each shard (if not -1)
-            for (long s = 0; s < nshard; s++) {
+            for (long s = 0; s < static_cast<long>(nshard); s++) {
                 pointer[s] = 0;
                 if (I_in[stride * s] >= 0) {
                     heap_push<C>(
@@ -210,7 +210,7 @@ void merge_knn_results(
             distance_t* D = distances + i * k;
             idx_t* I = labels + i * k;
 
-            int j;
+            size_t j;
             for (j = 0; j < k && heap_size > 0; j++) {
                 // pop element from best shard
                 int s = shard_ids[0]; // top of heap
@@ -221,7 +221,7 @@ void merge_knn_results(
                 // pop from shard, advance pointer for this shard
                 heap_pop<C>(heap_size--, heap_vals, shard_ids);
                 p++;
-                if (p < k && I_in[stride * s + p] >= 0) {
+                if (static_cast<size_t>(p) < k && I_in[stride * s + p] >= 0) {
                     heap_push<C>(
                             ++heap_size,
                             heap_vals,

faiss/utils/distances.cpp

@@ -207,7 +207,7 @@ void fvec_norms_L2(
         size_t d,
         size_t nx) {
 #pragma omp parallel for if (nx > 10000)
-    for (int64_t i = 0; i < nx; i++) {
+    for (int64_t i = 0; i < static_cast<int64_t>(nx); i++) {
         nr[i] = sqrtf(fvec_norm_L2sqr_dispatch(x + i * d, d));
     }
 }
@@ -218,7 +218,7 @@ void fvec_norms_L2sqr(
         size_t d,
         size_t nx) {
 #pragma omp parallel for if (nx > 10000)
-    for (int64_t i = 0; i < nx; i++) {
+    for (int64_t i = 0; i < static_cast<int64_t>(nx); i++) {
         nr[i] = fvec_norm_L2sqr_dispatch(x + i * d, d);
     }
 }
@@ -247,14 +247,14 @@ void fvec_norms_L2sqr(
     }
 
 void fvec_renorm_L2_noomp(size_t d, size_t nx, float* __restrict x) {
-    for (int64_t i = 0; i < nx; i++) {
+    for (int64_t i = 0; i < static_cast<int64_t>(nx); i++) {
         FVEC_RENORM_L2_IMPL
     }
 }
 
 void fvec_renorm_L2_omp(size_t d, size_t nx, float* __restrict x) {
 #pragma omp parallel for if (nx > 10000)
-    for (int64_t i = 0; i < nx; i++) {
+    for (int64_t i = 0; i < static_cast<int64_t>(nx); i++) {
         FVEC_RENORM_L2_IMPL
     }
 }
@@ -290,7 +290,7 @@ void exhaustive_inner_product_seq(
     {
         SingleResultHandler resi(res);
 #pragma omp for
-        for (int64_t i = 0; i < nx; i++) {
+        for (int64_t i = 0; i < static_cast<int64_t>(nx); i++) {
             const float* x_i = x + i * d;
             const float* y_j = y;
 
@@ -324,7 +324,7 @@ void exhaustive_L2sqr_seq(
     {
         SingleResultHandler resi(res);
 #pragma omp for
-        for (int64_t i = 0; i < nx; i++) {
+        for (int64_t i = 0; i < static_cast<int64_t>(nx); i++) {
             const float* x_i = x + i * d;
             const float* y_j = y;
             resi.begin(i);
@@ -462,7 +462,7 @@ void exhaustive_L2sqr_blas_default_impl(
                        ip_block.get(),
                        &nyi);
             }
-            for (int64_t i = i0; i < i1; i++) {
+            for (size_t i = i0; i < i1; i++) {
                 float* ip_line = ip_block.get() + (i - i0) * (j1 - j0);
 
                 for (size_t j = j0; j < j1; j++) {
@@ -497,7 +497,7 @@ void exhaustive_L2sqr_blas(
         size_t nx,
         size_t ny,
         BlockResultHandler& res,
-        const float* y_norms = nullptr) {
+        const float* /* y_norms */ = nullptr) {
     exhaustive_L2sqr_blas_default_impl(x, y, d, nx, ny, res);
 }
 
@@ -563,7 +563,7 @@ void exhaustive_L2sqr_blas_cmax_avx2(
                        ip_block.get(),
                        &nyi);
             }
-            for (int64_t i = i0; i < i1; i++) {
+            for (size_t i = i0; i < i1; i++) {
                 float* ip_line = ip_block.get() + (i - i0) * (j1 - j0);
 
                 _mm_prefetch((const char*)ip_line, _MM_HINT_NTA);
@@ -772,7 +772,7 @@ void exhaustive_L2sqr_blas_cmax_sve(
                        ip_block.get(),
                        &nyi);
             }
-            for (int64_t i = i0; i < i1; i++) {
+            for (size_t i = i0; i < i1; i++) {
                 const size_t count = j1 - j0;
                 float* ip_line = ip_block.get() + (i - i0) * count;
 
@@ -947,7 +947,8 @@ struct Run_search_inner_product {
            size_t d,
            size_t nx,
            size_t ny) {
-        if (res.sel || nx < distance_compute_blas_threshold) {
+        if (res.sel ||
+            nx < static_cast<size_t>(distance_compute_blas_threshold)) {
             exhaustive_inner_product_seq(x, y, d, nx, ny, res);
         } else {
             exhaustive_inner_product_blas(x, y, d, nx, ny, res);
@@ -965,7 +966,8 @@ struct Run_search_L2sqr {
            size_t nx,
            size_t ny,
            const float* y_norm2) {
-        if (res.sel || nx < distance_compute_blas_threshold) {
+        if (res.sel ||
+            nx < static_cast<size_t>(distance_compute_blas_threshold)) {
             exhaustive_L2sqr_seq(x, y, d, nx, ny, res);
         } else {
             exhaustive_L2sqr_blas(x, y, d, nx, ny, res, y_norm2);
@@ -1131,7 +1133,7 @@ void fvec_inner_products_by_idx(
         size_t nx,
         size_t ny) {
 #pragma omp parallel for
-    for (int64_t j = 0; j < nx; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(nx); j++) {
         const int64_t* __restrict idsj = ids + j * ny;
         const float* xj = x + j * d;
         float* __restrict ipj = ip + j * ny;
@@ -1156,7 +1158,7 @@ void fvec_L2sqr_by_idx(
         size_t nx,
         size_t ny) {
 #pragma omp parallel for
-    for (int64_t j = 0; j < nx; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(nx); j++) {
         const int64_t* __restrict idsj = ids + j * ny;
         const float* xj = x + j * d;
         float* __restrict disj = dis + j * ny;
@@ -1179,7 +1181,7 @@ void pairwise_indexed_L2sqr(
         const int64_t* iy,
         float* dis) {
 #pragma omp parallel for if (n > 1)
-    for (int64_t j = 0; j < n; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(n); j++) {
         if (ix[j] >= 0 && iy[j] >= 0) {
             dis[j] = fvec_L2sqr_dispatch(x + d * ix[j], y + d * iy[j], d);
         } else {
@@ -1197,7 +1199,7 @@ void pairwise_indexed_inner_product(
         const int64_t* iy,
         float* dis) {
 #pragma omp parallel for if (n > 1)
-    for (int64_t j = 0; j < n; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(n); j++) {
         if (ix[j] >= 0 && iy[j] >= 0) {
             dis[j] = fvec_inner_product_dispatch(
                     x + d * ix[j], y + d * iy[j], d);
@@ -1226,7 +1228,7 @@ void knn_inner_products_by_idx(
     }
 
 #pragma omp parallel for if (nx > 100)
-    for (int64_t i = 0; i < nx; i++) {
+    for (int64_t i = 0; i < static_cast<int64_t>(nx); i++) {
         const float* x_ = x + i * d;
         const int64_t* idsi = ids + i * ld_ids;
         size_t j;
@@ -1235,7 +1237,7 @@ void knn_inner_products_by_idx(
         minheap_heapify(k, simi, idxi);
 
         for (j = 0; j < nsubset; j++) {
-            if (idsi[j] < 0 || idsi[j] >= ny) {
+            if (idsi[j] < 0 || static_cast<size_t>(idsi[j]) >= ny) {
                 break;
             }
             float ip = fvec_inner_product_dispatch(x_, y + d * idsi[j], d);
@@ -1264,14 +1266,14 @@ void knn_L2sqr_by_idx(
         ld_ids = ny;
     }
 #pragma omp parallel for if (nx > 100)
-    for (int64_t i = 0; i < nx; i++) {
+    for (int64_t i = 0; i < static_cast<int64_t>(nx); i++) {
         const float* x_ = x + i * d;
         const int64_t* __restrict idsi = ids + i * ld_ids;
         float* __restrict simi = res_vals + i * k;
         int64_t* __restrict idxi = res_ids + i * k;
         maxheap_heapify(k, simi, idxi);
         for (size_t j = 0; j < nsubset; j++) {
-            if (idsi[j] < 0 || idsi[j] >= ny) {
+            if (idsi[j] < 0 || static_cast<size_t>(idsi[j]) >= ny) {
                 break;
             }
             float disij = fvec_L2sqr_dispatch(x_, y + d * idsi[j], d);
@@ -1357,7 +1359,7 @@ void inner_product_to_L2sqr(
         size_t n1,
         size_t n2) {
 #pragma omp parallel for
-    for (int64_t j = 0; j < n1; j++) {
+    for (int64_t j = 0; j < static_cast<int64_t>(n1); j++) {
         float* disj = dis + j * n2;
         for (size_t i = 0; i < n2; i++) {
             disj[i] = nr1[j] + nr2[i] - 2 * disj[i];

faiss/utils/distances_fused/distances_fused.cpp

@@ -35,6 +35,11 @@ bool exhaustive_L2sqr_fused_cmax(
     return exhaustive_L2sqr_fused_cmax_simdlib(x, y, d, nx, ny, res, y_norms);
 #else
     // not supported, please use a general-purpose kernel
+    (void)x;
+    (void)y;
+    (void)d;
+    (void)res;
+    (void)y_norms;
     return false;
 #endif
 }

faiss/utils/distances_fused/simdlib_based.cpp

@@ -260,7 +260,8 @@ void exhaustive_L2sqr_fused_cmax(
     const size_t nx_p = (nx / NX_POINTS_PER_LOOP) * NX_POINTS_PER_LOOP;
     // the main loop.
 #pragma omp parallel for schedule(dynamic)
-    for (int64_t i = 0; i < nx_p; i += NX_POINTS_PER_LOOP) {
+    for (int64_t i = 0; i < static_cast<int64_t>(nx_p);
+         i += NX_POINTS_PER_LOOP) {
         kernel<DIM, NX_POINTS_PER_LOOP, NY_POINTS_PER_LOOP>(
                 x, y, y_transposed.data(), ny, res, y_norms, i);
     }

faiss/utils/extra_distances.cpp

@@ -41,14 +41,14 @@ struct ExtraDistanceComputer : FlatCodesDistanceComputer {
     }
 
     ExtraDistanceComputer(
-            const VD& vd,
+            const VD& vd_in,
             const float* xb,
-            size_t nb,
-            const float* q = nullptr)
-            : FlatCodesDistanceComputer((uint8_t*)xb, vd.d * sizeof(float)),
-              vd(vd),
-              nb(nb),
-              q(q),
+            size_t nb_in,
+            const float* q_in = nullptr)
+            : FlatCodesDistanceComputer((uint8_t*)xb, vd_in.d * sizeof(float)),
+              vd(vd_in),
+              nb(nb_in),
+              q(q_in),
               b(xb) {}
 
     void set_query(const float* x) override {
@@ -119,7 +119,7 @@ void knn_extra_metrics(
             size_t i1 = std::min(i0 + check_period, nx);
 
 #pragma omp parallel for
-            for (int64_t i = i0; i < i1; i++) {
+            for (int64_t i = i0; i < static_cast<int64_t>(i1); i++) {
                 const float* x_i = x + i * d;
                 const float* y_j = y;
                 size_t j;

faiss/utils/hamming-inl.h

@@ -10,9 +10,9 @@
 namespace faiss {
 
 // BitstringWriter and BitstringReader functions
-inline BitstringWriter::BitstringWriter(uint8_t* code, size_t code_size)
-        : code(code), code_size(code_size), i(0) {
-    memset(code, 0, code_size);
+inline BitstringWriter::BitstringWriter(uint8_t* code_in, size_t code_size_in)
+        : code(code_in), code_size(code_size_in), i(0) {
+    memset(code_in, 0, code_size_in);
 }
 
 inline void BitstringWriter::write(uint64_t x, int nbit) {
@@ -36,8 +36,10 @@ inline void BitstringWriter::write(uint64_t x, int nbit) {
     }
 }
 
-inline BitstringReader::BitstringReader(const uint8_t* code, size_t code_size)
-        : code(code), code_size(code_size), i(0) {}
+inline BitstringReader::BitstringReader(
+        const uint8_t* code_in,
+        size_t code_size_in)
+        : code(code_in), code_size(code_size_in), i(0) {}
 
 inline uint64_t BitstringReader::read(int nbit) {
     assert(code_size * 8 >= nbit + i);
@@ -85,18 +87,18 @@ struct HCounterState {
     int k;
 
     HCounterState(
-            int* counters,
-            int64_t* ids_per_dis,
+            int* counters_in,
+            int64_t* ids_per_dis_in,
             const uint8_t* x,
             int d,
-            int k)
-            : counters(counters),
-              ids_per_dis(ids_per_dis),
+            int k_in)
+            : counters(counters_in),
+              ids_per_dis(ids_per_dis_in),
               hc(x, d / 8),
               thres(d + 1),
               count_lt(0),
               count_eq(0),
-              k(k) {}
+              k(k_in) {}
 
     void update_counter(const uint8_t* y, size_t j) {
         int32_t dis = hc.hamming(y);