Reduce Warnings: address C4127 "conditional expression is constant" warnings (#1989)

* Address false-positive -Wreturn-type warnings with GCC 11

Author: eramongodb

src/common/src/mlib/config.h

@@ -350,4 +350,9 @@
  */
 #define mlib_typeof(...) MLIB_IF_ELSE (mlib_have_typeof ()) (__typeof__) (__mlib_typeof_is_not_supported) (__VA_ARGS__)
 
+/**
+ * @brief Disable warnings for constant conditional expressions.
+ */
+#define mlib_disable_constant_conditional_expression_warnings() mlib_msvc_warning (disable : 4127)
+
 #endif // MLIB_CONFIG_H_INCLUDED

src/common/tests/test-mlib.c

@@ -308,6 +308,7 @@ _test_cmp (void)
    // Unintuitive result due to integer promotion:
    mlib_diagnostic_push ();
    mlib_gnu_warning_disable ("-Wsign-compare");
+   mlib_disable_constant_conditional_expression_warnings ();
    ASSERT (-27 > 20u);
    mlib_diagnostic_pop ();
    // mlib_cmp produces the correct answer:

src/libbson/src/bson/bson-json.c

@@ -28,6 +28,7 @@
 #include <bson/bson-iso8601-private.h>
 
 #include <mlib/cmp.h>
+#include <mlib/config.h>
 #include <common-b64-private.h>
 #include <jsonsl/jsonsl.h>
 
@@ -270,22 +271,25 @@ _noop (void)
 #define STACK_IS_DBPOINTER (STACK_FRAME_TYPE == BSON_JSON_FRAME_DBPOINTER)
 #define FRAME_TYPE_HAS_BSON(_type) ((_type) == BSON_JSON_FRAME_SCOPE || (_type) == BSON_JSON_FRAME_DBPOINTER)
 #define STACK_HAS_BSON FRAME_TYPE_HAS_BSON (STACK_FRAME_TYPE)
-#define STACK_PUSH(frame_type)                       \
-   do {                                              \
-      if (bson->n >= (STACK_MAX - 1)) {              \
-         return;                                     \
-      }                                              \
-      bson->n++;                                     \
-      if (STACK_HAS_BSON) {                          \
-         if (FRAME_TYPE_HAS_BSON (frame_type)) {     \
-            bson_reinit (STACK_BSON_CHILD);          \
-         } else {                                    \
-            bson_destroy (STACK_BSON_CHILD);         \
-         }                                           \
-      } else if (FRAME_TYPE_HAS_BSON (frame_type)) { \
-         bson_init (STACK_BSON_CHILD);               \
-      }                                              \
-      STACK_FRAME_TYPE = frame_type;                 \
+#define STACK_PUSH(frame_type)                                  \
+   do {                                                         \
+      if (bson->n >= (STACK_MAX - 1)) {                         \
+         return;                                                \
+      }                                                         \
+      bson->n++;                                                \
+      mlib_diagnostic_push ();                                  \
+      mlib_disable_constant_conditional_expression_warnings (); \
+      if (STACK_HAS_BSON) {                                     \
+         if (FRAME_TYPE_HAS_BSON (frame_type)) {                \
+            bson_reinit (STACK_BSON_CHILD);                     \
+         } else {                                               \
+            bson_destroy (STACK_BSON_CHILD);                    \
+         }                                                      \
+      } else if (FRAME_TYPE_HAS_BSON (frame_type)) {            \
+         bson_init (STACK_BSON_CHILD);                          \
+      }                                                         \
+      mlib_diagnostic_pop ();                                   \
+      STACK_FRAME_TYPE = frame_type;                            \
    } while (0)
 #define STACK_PUSH_ARRAY(statement)       \
    do {                                   \

src/libbson/src/bson/bson.c

@@ -28,6 +28,8 @@
 #include <string.h>
 #include <math.h>
 
+#include <mlib/config.h>
+
 
 typedef enum {
    BSON_VALIDATE_PHASE_START,
@@ -313,7 +315,10 @@ BSON_STATIC_ASSERT2 (max_alloc_grow_fits_min_sizet, (uint64_t) BSON_MAX_SIZE * 2
 // Add a bytes+length pair only if `_length > 0`.
 // Append failure if `n_bytes` will exceed BSON max size.
 #define BSON_APPEND_BYTES_ADD_ARGUMENT(_list, _bytes, _length)        \
+   mlib_diagnostic_push ();                                           \
+   mlib_disable_constant_conditional_expression_warnings ();          \
    if (BSON_UNLIKELY ((_length) > BSON_MAX_SIZE - (_list).n_bytes)) { \
+      mlib_diagnostic_pop ();                                         \
       goto append_failure;                                            \
    } else if ((_length) > 0) {                                        \
       *(_list).current++ = (_bson_append_bytes_arg){                  \

src/libbson/tests/test-oid.c

@@ -28,6 +28,8 @@
 
 #include <limits.h>
 
+#include <mlib/config.h>
+
 #include "TestSuite.h"
 #include <common-macros-private.h> // BEGIN_IGNORE_DEPRECATIONS
 #include <common-json-private.h>
@@ -237,7 +239,10 @@ test_bson_oid_get_time_t (void)
 
    /* if time_t is a signed int32, then a negative value may be interpreted
     * as a negative date when printing. */
+   mlib_diagnostic_push ();
+   mlib_disable_constant_conditional_expression_warnings ();
    if (sizeof (time_t) == 8) {
+      mlib_diagnostic_pop ();
       bson_oid_init_from_string (&oid, "7FFFFFFF0000000000000000");
       str = get_time_as_string (&oid);
       ASSERT_CMPSTR (str, "2038-01-19T03:14:07Z");

src/libmongoc/src/mongoc/mcd-nsinfo.c

@@ -20,6 +20,8 @@
 #include <mongoc/mongoc-error-private.h>
 #include <mongoc/uthash.h>
 
+#include <mlib/config.h>
+
 typedef struct {
    char *ns; // Hash key.
    int32_t index;
@@ -79,7 +81,11 @@ mcd_nsinfo_append (mcd_nsinfo_t *self, const char *ns, bson_error_t *error)
    // Add to hash table.
    ns_to_index_t *entry = bson_malloc (sizeof (*entry));
    *entry = (ns_to_index_t){.index = ns_index, .ns = bson_strdup (ns), .hh = {0}};
+
+   mlib_diagnostic_push ();
+   mlib_disable_constant_conditional_expression_warnings ();
    HASH_ADD_KEYPTR (hh, self->n2i, entry->ns, strlen (entry->ns), entry);
+   mlib_diagnostic_pop ();
 
    // Append to buffer.
    bson_t mcd_nsinfo_bson = BSON_INITIALIZER;
@@ -96,7 +102,12 @@ mcd_nsinfo_find (const mcd_nsinfo_t *self, const char *ns)
    BSON_ASSERT_PARAM (ns);
 
    ns_to_index_t *found;
+
+   mlib_diagnostic_push ();
+   mlib_disable_constant_conditional_expression_warnings ();
    HASH_FIND_STR (self->n2i, ns, found);
+   mlib_diagnostic_pop ();
+
    if (found == NULL) {
       return -1;
    }

src/libmongoc/src/mongoc/mongoc-handshake.c

@@ -39,6 +39,7 @@
 #include <common-bson-dsl-private.h>
 #include <common-string-private.h>
 #include <mlib/cmp.h>
+#include <mlib/config.h>
 
 /*
  * Global handshake data instance. Initialized at startup from mongoc_init
@@ -177,9 +178,12 @@ _mongoc_handshake_get_config_hex_string (void)
    _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SHM_COUNTERS);
 #endif
 
+   mlib_diagnostic_push ();
+   mlib_disable_constant_conditional_expression_warnings ();
    if (MONGOC_TRACE_ENABLED) {
       _set_bit (bf, byte_count, MONGOC_MD_FLAG_TRACE);
    }
+   mlib_diagnostic_pop ();
 
 #ifdef MONGOC_ENABLE_CLIENT_SIDE_ENCRYPTION
    _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_CLIENT_SIDE_ENCRYPTION);
@@ -189,9 +193,12 @@ _mongoc_handshake_get_config_hex_string (void)
    _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_MONGODB_AWS_AUTH);
 #endif
 
+   mlib_diagnostic_push ();
+   mlib_disable_constant_conditional_expression_warnings ();
    if (MONGOC_SRV_ENABLED) {
       _set_bit (bf, byte_count, MONGOC_MD_FLAG_ENABLE_SRV);
    }
+   mlib_diagnostic_pop ();
 
    mcommon_string_append_t append;
    mcommon_string_set_append (mcommon_string_new_with_capacity ("0x", 2, 2 + byte_count * 2), &append);

src/libmongoc/src/mongoc/mongoc-ocsp-cache.c

@@ -22,6 +22,7 @@
 #include <mongoc/mongoc-trace-private.h>
 #include <bson/bson.h>
 #include <common-thread-private.h>
+#include <mlib/config.h>
 
 typedef struct _cache_entry_list_t {
    struct _cache_entry_list_t *next;
@@ -43,8 +44,9 @@ static int
 cache_cmp (cache_entry_list_t *out, OCSP_CERTID *id)
 {
    ENTRY;
-   if (!out || !out->id || !id)
+   if (!out || !out->id || !id) {
       RETURN (1);
+   }
    RETURN (OCSP_id_cmp (out->id, id));
 }
 

src/libmongoc/src/mongoc/mongoc-server-description.c

@@ -30,6 +30,8 @@
 #include <common-atomic-private.h>
 #include <common-oid-private.h>
 
+#include <mlib/config.h>
+
 #include <stdio.h>
 
 #define ALPHA 0.2
@@ -556,28 +558,34 @@ mongoc_server_description_handle_hello (mongoc_server_description_t *sd,
          }
       } else if (strcmp ("isWritablePrimary", bson_iter_key (&iter)) == 0 ||
                  strcmp (HANDSHAKE_RESPONSE_LEGACY_HELLO, bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_BOOL (&iter))
+         if (!BSON_ITER_HOLDS_BOOL (&iter)) {
             GOTO (typefailure);
+         }
          is_primary = bson_iter_bool (&iter);
       } else if (strcmp ("helloOk", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_BOOL (&iter))
+         if (!BSON_ITER_HOLDS_BOOL (&iter)) {
             GOTO (typefailure);
+         }
          sd->hello_ok = bson_iter_bool (&iter);
       } else if (strcmp ("me", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_UTF8 (&iter))
+         if (!BSON_ITER_HOLDS_UTF8 (&iter)) {
             GOTO (typefailure);
+         }
          sd->me = bson_iter_utf8 (&iter, NULL);
       } else if (strcmp ("maxMessageSizeBytes", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_INT32 (&iter))
+         if (!BSON_ITER_HOLDS_INT32 (&iter)) {
             GOTO (typefailure);
+         }
          sd->max_msg_size = bson_iter_int32 (&iter);
       } else if (strcmp ("maxBsonObjectSize", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_INT32 (&iter))
+         if (!BSON_ITER_HOLDS_INT32 (&iter)) {
             GOTO (typefailure);
+         }
          sd->max_bson_obj_size = bson_iter_int32 (&iter);
       } else if (strcmp ("maxWriteBatchSize", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_INT32 (&iter))
+         if (!BSON_ITER_HOLDS_INT32 (&iter)) {
             GOTO (typefailure);
+         }
          sd->max_write_batch_size = bson_iter_int32 (&iter);
       } else if (strcmp ("logicalSessionTimeoutMinutes", bson_iter_key (&iter)) == 0) {
          if (BSON_ITER_HOLDS_NUMBER (&iter)) {
@@ -589,68 +597,81 @@ mongoc_server_description_handle_hello (mongoc_server_description_t *sd,
             GOTO (typefailure);
          }
       } else if (strcmp ("minWireVersion", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_INT32 (&iter))
+         if (!BSON_ITER_HOLDS_INT32 (&iter)) {
             GOTO (typefailure);
+         }
          sd->min_wire_version = bson_iter_int32 (&iter);
       } else if (strcmp ("maxWireVersion", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_INT32 (&iter))
+         if (!BSON_ITER_HOLDS_INT32 (&iter)) {
             GOTO (typefailure);
+         }
          sd->max_wire_version = bson_iter_int32 (&iter);
       } else if (strcmp ("msg", bson_iter_key (&iter)) == 0) {
          const char *msg;
-         if (!BSON_ITER_HOLDS_UTF8 (&iter))
+         if (!BSON_ITER_HOLDS_UTF8 (&iter)) {
             GOTO (typefailure);
+         }
          msg = bson_iter_utf8 (&iter, NULL);
          if (msg && 0 == strcmp (msg, "isdbgrid")) {
             is_shard = true;
          }
       } else if (strcmp ("setName", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_UTF8 (&iter))
+         if (!BSON_ITER_HOLDS_UTF8 (&iter)) {
             GOTO (typefailure);
+         }
          sd->set_name = bson_iter_utf8 (&iter, NULL);
       } else if (strcmp ("setVersion", bson_iter_key (&iter)) == 0) {
          mongoc_server_description_set_set_version (sd, bson_iter_as_int64 (&iter));
       } else if (strcmp ("electionId", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_OID (&iter))
+         if (!BSON_ITER_HOLDS_OID (&iter)) {
             GOTO (typefailure);
+         }
          mongoc_server_description_set_election_id (sd, bson_iter_oid (&iter));
       } else if (strcmp ("secondary", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_BOOL (&iter))
+         if (!BSON_ITER_HOLDS_BOOL (&iter)) {
             GOTO (typefailure);
+         }
          is_secondary = bson_iter_bool (&iter);
       } else if (strcmp ("hosts", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_ARRAY (&iter))
+         if (!BSON_ITER_HOLDS_ARRAY (&iter)) {
             GOTO (typefailure);
+         }
          bson_iter_array (&iter, &len, &bytes);
          bson_destroy (&sd->hosts);
          BSON_ASSERT (bson_init_static (&sd->hosts, bytes, len));
       } else if (strcmp ("passives", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_ARRAY (&iter))
+         if (!BSON_ITER_HOLDS_ARRAY (&iter)) {
             GOTO (typefailure);
+         }
          bson_iter_array (&iter, &len, &bytes);
          bson_destroy (&sd->passives);
          BSON_ASSERT (bson_init_static (&sd->passives, bytes, len));
       } else if (strcmp ("arbiters", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_ARRAY (&iter))
+         if (!BSON_ITER_HOLDS_ARRAY (&iter)) {
             GOTO (typefailure);
+         }
          bson_iter_array (&iter, &len, &bytes);
          bson_destroy (&sd->arbiters);
          BSON_ASSERT (bson_init_static (&sd->arbiters, bytes, len));
       } else if (strcmp ("primary", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_UTF8 (&iter))
+         if (!BSON_ITER_HOLDS_UTF8 (&iter)) {
             GOTO (typefailure);
+         }
          sd->current_primary = bson_iter_utf8 (&iter, NULL);
       } else if (strcmp ("arbiterOnly", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_BOOL (&iter))
+         if (!BSON_ITER_HOLDS_BOOL (&iter)) {
             GOTO (typefailure);
+         }
          is_arbiter = bson_iter_bool (&iter);
       } else if (strcmp ("isreplicaset", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_BOOL (&iter))
+         if (!BSON_ITER_HOLDS_BOOL (&iter)) {
             GOTO (typefailure);
+         }
          is_replicaset = bson_iter_bool (&iter);
       } else if (strcmp ("tags", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_DOCUMENT (&iter))
+         if (!BSON_ITER_HOLDS_DOCUMENT (&iter)) {
             GOTO (typefailure);
+         }
          bson_iter_document (&iter, &len, &bytes);
          bson_destroy (&sd->tags);
          BSON_ASSERT (bson_init_static (&sd->tags, bytes, len));
@@ -664,8 +685,9 @@ mongoc_server_description_handle_hello (mongoc_server_description_t *sd,
 
          sd->last_write_date_ms = bson_iter_date_time (&child);
       } else if (strcmp ("compression", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_ARRAY (&iter))
+         if (!BSON_ITER_HOLDS_ARRAY (&iter)) {
             GOTO (typefailure);
+         }
          bson_iter_array (&iter, &len, &bytes);
          bson_destroy (&sd->compressors);
          BSON_ASSERT (bson_init_static (&sd->compressors, bytes, len));
@@ -681,12 +703,14 @@ mongoc_server_description_handle_hello (mongoc_server_description_t *sd,
          mongoc_server_description_set_topology_version (sd, &incoming_topology_version);
          bson_destroy (&incoming_topology_version);
       } else if (strcmp ("serviceId", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_OID (&iter))
+         if (!BSON_ITER_HOLDS_OID (&iter)) {
             GOTO (typefailure);
+         }
          bson_oid_copy_unsafe (bson_iter_oid (&iter), &sd->service_id);
       } else if (strcmp ("connectionId", bson_iter_key (&iter)) == 0) {
-         if (!BSON_ITER_HOLDS_NUMBER (&iter))
+         if (!BSON_ITER_HOLDS_NUMBER (&iter)) {
             GOTO (typefailure);
+         }
          sd->server_connection_id = bson_iter_as_int64 (&iter);
       }
    }

src/libmongoc/src/mongoc/mongoc-server-monitor.c

@@ -29,6 +29,7 @@
 #include <mongoc/mongoc-trace-private.h>
 #include <mongoc/mongoc-structured-log-private.h>
 #include <common-atomic-private.h>
+#include <mlib/config.h>
 
 #include <inttypes.h>
 
@@ -116,11 +117,15 @@ static BSON_GNUC_PRINTF (3, 4) void _server_monitor_log (mongoc_server_monitor_t
 }
 
 #define MONITOR_LOG(sm, ...)                                            \
-   do {                                                                 \
+   if (1) {                                                             \
+      mlib_diagnostic_push ();                                          \
+      mlib_disable_constant_conditional_expression_warnings ();         \
       if (MONGOC_TRACE_ENABLED) {                                       \
          _server_monitor_log (sm, MONGOC_LOG_LEVEL_TRACE, __VA_ARGS__); \
       }                                                                 \
-   } while (0)
+      mlib_diagnostic_pop ();                                           \
+   } else                                                               \
+      ((void) 0)
 
 /* TODO CDRIVER-3710 use MONGOC_LOG_LEVEL_ERROR */
 #define MONITOR_LOG_ERROR(sm, ...) _server_monitor_log (sm, MONGOC_LOG_LEVEL_DEBUG, __VA_ARGS__)