MONGOCRYPT-783 address -Wpedantic warnings for anonymous structs and unions (#972)

Author: eramongodb

src/csfle-markup.cpp

@@ -102,8 +102,8 @@ int do_main(int argc, const char *const *argv) {
 
     mcr_dll csfle = mcr_dll_open(argv[1]);
     auto close_csfle = DEFER({ mcr_dll_close(csfle); });
-    if (csfle.error_string.data) {
-        std::cerr << "Failed to open [" << argv[1] << "] as a dynamic library: " << csfle.error_string.data << '\n';
+    if (csfle.error_string.raw.data) {
+        std::cerr << "Failed to open [" << argv[1] << "] as a dynamic library: " << csfle.error_string.raw.data << '\n';
         return 3;
     }
 

src/mlib/path.h

@@ -76,12 +76,12 @@ static inline mstr mpath_current_path(void) {
     }
 #else
     mstr_mut mut = mstr_new(8096);
-    char *p = getcwd(mut.data, mut.len);
+    char *p = getcwd(mut.raw.data, mut.raw.len);
     if (p == NULL) {
         mstr_free(mut.mstr);
         return MSTR_NULL;
     }
-    mstr ret = mstr_copy_cstr(mut.data);
+    mstr ret = mstr_copy_cstr(mut.raw.data);
     mstr_free(mut.mstr);
     return ret;
 #endif
@@ -167,7 +167,7 @@ static inline mstr mpath_join(mstr_view base, mstr_view suffix, mpath_format f)
     // We must insert a path separator between the two strings
     assert(base.len <= SIZE_MAX - suffix.len - 1u);
     mstr_mut r = mstr_new(base.len + suffix.len + 1);
-    char *p = r.data;
+    char *p = r.raw.data;
     memcpy(p, base.data, base.len);
     p += base.len;
     *p++ = mpath_preferred_sep(f);
@@ -255,7 +255,7 @@ static inline mstr_view mpath_relative_path(mstr_view path, mpath_format f) {
 static inline mstr mpath_to_format(mpath_format from, mstr_view path, mpath_format to) {
     mstr_mut ret = mstr_new(path.len);
     const char *p = path.data;
-    char *out = ret.data;
+    char *out = ret.raw.data;
     const char *stop = path.data + path.len;
     for (; p != stop; ++p, ++out) {
         if (mpath_is_sep(*p, from)) {

src/mlib/str.h

@@ -76,28 +76,26 @@ typedef struct mstr_view {
  * relinquish ownership of that `mstr` to the callee/caller, respectively.
  * Passing or returning an `mstr_view` is non-owning.
  */
-typedef struct mstr {
-    union {
-        struct {
-            /**
-             * @brief Pointer to the beginning of the code unit array.
-             *
-             * @note DO NOT MODIFY
-             */
-            const char *data;
-            /**
-             * @brief Length of the pointed-to code unit array
-             *
-             * @note DO NOT MODIFY
-             */
-            size_t len;
-        };
-
+typedef union mstr {
+    struct {
+        /**
+         * @brief Pointer to the beginning of the code unit array.
+         *
+         * @note DO NOT MODIFY
+         */
+        const char *data;
         /**
-         * @brief A non-owning `mstr_view` of the string
+         * @brief Length of the pointed-to code unit array
+         *
+         * @note DO NOT MODIFY
          */
-        mstr_view view;
-    };
+        size_t len;
+    } raw;
+
+    /**
+     * @brief A non-owning `mstr_view` of the string
+     */
+    mstr_view view;
 } mstr;
 
 /**
@@ -106,34 +104,32 @@ typedef struct mstr {
  * Returned by @ref mstr_new(). Once initialization is complete, the result can
  * be used as an @ref mstr by accessing the @ref mstr_mut::mstr member.
  */
-typedef struct mstr_mut {
-    union {
-        struct {
-            /**
-             * @brief Pointer to the beginning of the mutable code unit array.
-             *
-             * @note DO NOT MODIFY THE POINTER VALUE. Only modify the pointed-to
-             * characters.
-             */
-            char *data;
-            /**
-             * @brief Length of the pointed-to code unit array.
-             *
-             * @note DO NOT MODIFY
-             */
-            size_t len;
-        };
-        /// Convert the mutable string to an immutable string
-        struct mstr mstr;
-        /// Convert the mutable string to an immutable string view
-        mstr_view view;
-    };
+typedef union mstr_mut {
+    struct {
+        /**
+         * @brief Pointer to the beginning of the mutable code unit array.
+         *
+         * @note DO NOT MODIFY THE POINTER VALUE. Only modify the pointed-to
+         * characters.
+         */
+        char *data;
+        /**
+         * @brief Length of the pointed-to code unit array.
+         *
+         * @note DO NOT MODIFY
+         */
+        size_t len;
+    } raw;
+    /// Convert the mutable string to an immutable string
+    union mstr mstr;
+    /// Convert the mutable string to an immutable string view
+    mstr_view view;
 } mstr_mut;
 
 /**
  * @brief A null @ref mstr
  */
-#define MSTR_NULL (MLIB_INIT(mstr){{{NULL, 0}}})
+#define MSTR_NULL (MLIB_INIT(mstr){{NULL, 0}})
 /**
  * @brief A null @ref mstr_view
  */
@@ -159,7 +155,7 @@ typedef struct mstr_mut {
 static inline mstr_mut mstr_new(size_t len) {
 #ifndef __clang_analyzer__
     assert(len < SIZE_MAX);
-    return MLIB_INIT(mstr_mut){{{(char *)calloc(1, len + 1), len}}};
+    return MLIB_INIT(mstr_mut){{(char *)calloc(1, len + 1), len}};
 #else
     // Clang-analyzer is smart enough to see the calloc(), but not smart enough
     // to link it to the free() in mstr_free()
@@ -201,7 +197,7 @@ static inline mstr_view mstrv_view_cstr(const char *s) {
  */
 static inline mstr mstr_copy_data(const char *s, size_t len) {
     mstr_mut r = mstr_new(len);
-    memcpy(r.data, s, len);
+    memcpy(r.raw.data, s, len);
     return r.mstr;
 }
 
@@ -231,7 +227,7 @@ static inline mstr mstr_copy(mstr_view s) {
  * @param s The string to free
  */
 static inline void mstr_free(mstr s) {
-    free((char *)s.data);
+    free((char *)s.raw.data);
 }
 
 /**
@@ -242,21 +238,21 @@ static inline void mstr_free(mstr s) {
  * @param new_len The new length of the string
  */
 static inline void mstrm_resize(mstr_mut *s, size_t new_len) {
-    if (new_len <= s->len) {
-        s->len = new_len;
+    if (new_len <= s->raw.len) {
+        s->raw.len = new_len;
     } else {
-        const size_t old_len = s->len;
+        const size_t old_len = s->raw.len;
 #ifndef __clang_analyzer__
         // Clang-analyzer is smart enough to see the calloc(), but not smart
         // enough to link it to the free() in mstr_free()
         assert(new_len < SIZE_MAX);
-        s->data = (char *)realloc((char *)s->data, new_len + 1);
+        s->raw.data = (char *)realloc((char *)s->raw.data, new_len + 1);
 #endif
-        s->len = new_len;
+        s->raw.len = new_len;
         assert(new_len >= old_len);
-        memset(s->data + old_len, 0, new_len - old_len);
+        memset(s->raw.data + old_len, 0, new_len - old_len);
     }
-    s->data[new_len] = (char)0;
+    s->raw.data[new_len] = (char)0;
 }
 
 /**
@@ -375,7 +371,7 @@ static inline mstr mstr_splice(mstr_view s, size_t at, size_t del_count, mstr_vi
     assert(s.len - del_count <= SIZE_MAX - insert.len);
     const size_t new_size = s.len - del_count + insert.len;
     mstr_mut ret = mstr_new(new_size);
-    char *p = ret.data;
+    char *p = ret.raw.data;
     memcpy(p, s.data, at);
     p += at;
     if (insert.data) {
@@ -457,7 +453,7 @@ static inline mstr mstr_substr(mstr_view s, size_t at, size_t len) {
         len = remain;
     }
     mstr_mut r = mstr_new(len);
-    memcpy(r.data, s.data + at, len);
+    memcpy(r.raw.data, s.data + at, len);
     return r.mstr;
 }
 
@@ -613,7 +609,7 @@ static inline void _mstr_assert_(mstr_view left,
         if (!B) {
             mstr_assign(&pstr, mstr_prepend(pstr.view, mstrv_lit("not ")));
         }
-        _mstr_assert_fail_(left, pstr.data, right, file, line);
+        _mstr_assert_fail_(left, pstr.raw.data, right, file, line);
     }
 }
 
@@ -773,9 +769,9 @@ static inline mstr_narrow_result mstr_win32_narrow(const wchar_t *wstring) {
                                       wcflags,
                                       wstring,
                                       -1,
-                                      ret.data,
+                                      ret.raw.data,
                                       // Plus one byte for the NUL
-                                      (int)(ret.len + 1),
+                                      (int)(ret.raw.len + 1),
                                       NULL,
                                       NULL);
     assert(length == got_len);

src/mlib/str.test.c

@@ -12,9 +12,9 @@ int main(void) {
     (void)null_view;
 
     str = mstr_copy_cstr("foo");
-    CHECK(str.len == 3);
+    CHECK(str.raw.len == 3);
     MSTR_ASSERT_EQ(str.view, mstrv_lit("foo"));
-    CHECK(strncmp(str.data, "foo", 3) == 0);
+    CHECK(strncmp(str.raw.data, "foo", 3) == 0);
 
     mstr_inplace_append(&str, mstrv_lit("bar"));
     MSTR_ASSERT_EQ(str.view, mstrv_lit("foobar"));

src/mongocrypt-ciphertext-private.h

@@ -22,7 +22,7 @@
 #include "mongocrypt.h"
 
 /**
- * Produced by mongocrypt-marking.c from _mongocrypt_marking_t
+ * Produced by mongocrypt-marking.u.fle1.c from _mongocrypt_marking_t
  * as encrypted payloads for blob_subtypes:
  *   FLE1DeterministicEncryptedValue(1)
  *   FLE1RandomEncryptedValue(2)

src/mongocrypt-ctx-encrypt.c

@@ -281,13 +281,13 @@ static bool _collect_key_from_marking(void *ctx, _mongocrypt_buffer_t *in, mongo
     }
 
     if (marking.type == MONGOCRYPT_MARKING_FLE1_BY_ID) {
-        res = _mongocrypt_key_broker_request_id(kb, &marking.key_id);
+        res = _mongocrypt_key_broker_request_id(kb, &marking.u.fle1.key_id);
     } else if (marking.type == MONGOCRYPT_MARKING_FLE1_BY_ALTNAME) {
-        res = _mongocrypt_key_broker_request_name(kb, &marking.key_alt_name);
+        res = _mongocrypt_key_broker_request_name(kb, &marking.u.fle1.key_alt_name);
     } else {
         BSON_ASSERT(marking.type == MONGOCRYPT_MARKING_FLE2_ENCRYPTION);
-        res = _mongocrypt_key_broker_request_id(kb, &marking.fle2.index_key_id)
-           && _mongocrypt_key_broker_request_id(kb, &marking.fle2.user_key_id);
+        res = _mongocrypt_key_broker_request_id(kb, &marking.u.fle2.index_key_id)
+           && _mongocrypt_key_broker_request_id(kb, &marking.u.fle2.user_key_id);
     }
 
     if (!res) {
@@ -1318,23 +1318,23 @@ static bool _fle2_finalize_explicit(mongocrypt_ctx_t *ctx, mongocrypt_binary_t *
             }
         // fallthrough
         case MONGOCRYPT_QUERY_TYPE_RANGE:
-        case MONGOCRYPT_QUERY_TYPE_EQUALITY: marking.fle2.type = MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND; break;
+        case MONGOCRYPT_QUERY_TYPE_EQUALITY: marking.u.fle2.type = MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_FIND; break;
         default: _mongocrypt_ctx_fail_w_msg(ctx, "Invalid value for EncryptOpts.queryType"); goto fail;
         }
     } else {
-        marking.fle2.type = MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT;
+        marking.u.fle2.type = MONGOCRYPT_FLE2_PLACEHOLDER_TYPE_INSERT;
     }
 
     switch (ctx->opts.index_type.value) {
-    case MONGOCRYPT_INDEX_TYPE_EQUALITY: marking.fle2.algorithm = MONGOCRYPT_FLE2_ALGORITHM_EQUALITY; break;
-    case MONGOCRYPT_INDEX_TYPE_NONE: marking.fle2.algorithm = MONGOCRYPT_FLE2_ALGORITHM_UNINDEXED; break;
+    case MONGOCRYPT_INDEX_TYPE_EQUALITY: marking.u.fle2.algorithm = MONGOCRYPT_FLE2_ALGORITHM_EQUALITY; break;
+    case MONGOCRYPT_INDEX_TYPE_NONE: marking.u.fle2.algorithm = MONGOCRYPT_FLE2_ALGORITHM_UNINDEXED; break;
     case MONGOCRYPT_INDEX_TYPE_RANGEPREVIEW_DEPRECATED:
         if (ctx->crypt->opts.use_range_v2) {
             _mongocrypt_ctx_fail_w_msg(ctx, "Cannot use rangePreview index type with Range V2");
             goto fail;
         }
         // fallthrough
-    case MONGOCRYPT_INDEX_TYPE_RANGE: marking.fle2.algorithm = MONGOCRYPT_FLE2_ALGORITHM_RANGE; break;
+    case MONGOCRYPT_INDEX_TYPE_RANGE: marking.u.fle2.algorithm = MONGOCRYPT_FLE2_ALGORITHM_RANGE; break;
     default:
         // This might be unreachable because of other validation. Better safe than
         // sorry.
@@ -1364,12 +1364,12 @@ static bool _fle2_finalize_explicit(mongocrypt_ctx_t *ctx, mongocrypt_binary_t *
             goto fail;
         }
 
-        if (!bson_iter_init_find(&marking.v_iter, &new_v, "v")) {
+        if (!bson_iter_init_find(&marking.u.fle1.v_iter, &new_v, "v")) {
             _mongocrypt_ctx_fail_w_msg(ctx, "invalid input BSON, must contain 'v'");
             goto fail;
         }
 
-        marking.fle2.sparsity = ctx->opts.rangeopts.value.sparsity;
+        marking.u.fle2.sparsity = ctx->opts.rangeopts.value.sparsity;
 
     } else {
         bson_t as_bson;
@@ -1380,21 +1380,21 @@ static bool _fle2_finalize_explicit(mongocrypt_ctx_t *ctx, mongocrypt_binary_t *
             goto fail;
         }
 
-        if (!bson_iter_init_find(&marking.v_iter, &as_bson, "v")) {
+        if (!bson_iter_init_find(&marking.u.fle1.v_iter, &as_bson, "v")) {
             _mongocrypt_ctx_fail_w_msg(ctx, "invalid input BSON, must contain 'v'");
             goto fail;
         }
     }
 
-    _mongocrypt_buffer_copy_to(&ctx->opts.key_id, &marking.fle2.user_key_id);
+    _mongocrypt_buffer_copy_to(&ctx->opts.key_id, &marking.u.fle2.user_key_id);
     if (!_mongocrypt_buffer_empty(&ctx->opts.index_key_id)) {
-        _mongocrypt_buffer_copy_to(&ctx->opts.index_key_id, &marking.fle2.index_key_id);
+        _mongocrypt_buffer_copy_to(&ctx->opts.index_key_id, &marking.u.fle2.index_key_id);
     } else {
-        _mongocrypt_buffer_copy_to(&ctx->opts.key_id, &marking.fle2.index_key_id);
+        _mongocrypt_buffer_copy_to(&ctx->opts.key_id, &marking.u.fle2.index_key_id);
     }
 
     if (ctx->opts.contention_factor.set) {
-        marking.fle2.maxContentionFactor = ctx->opts.contention_factor.value;
+        marking.u.fle2.maxContentionFactor = ctx->opts.contention_factor.value;
     } else if (ctx->opts.index_type.value == MONGOCRYPT_INDEX_TYPE_EQUALITY) {
         _mongocrypt_ctx_fail_w_msg(ctx, "contention factor required for indexed algorithm");
         goto fail;
@@ -1495,11 +1495,11 @@ static bool _finalize(mongocrypt_ctx_t *ctx, mongocrypt_binary_t *out) {
             return _mongocrypt_ctx_fail_w_msg(ctx, "invalid msg, must contain 'v'");
         }
 
-        memcpy(&marking.v_iter, &iter, sizeof(bson_iter_t));
-        marking.algorithm = ctx->opts.algorithm;
-        _mongocrypt_buffer_set_to(&ctx->opts.key_id, &marking.key_id);
+        memcpy(&marking.u.fle1.v_iter, &iter, sizeof(bson_iter_t));
+        marking.u.fle1.algorithm = ctx->opts.algorithm;
+        _mongocrypt_buffer_set_to(&ctx->opts.key_id, &marking.u.fle1.key_id);
         if (ctx->opts.key_alt_names) {
-            bson_value_copy(&ctx->opts.key_alt_names->value, &marking.key_alt_name);
+            bson_value_copy(&ctx->opts.key_alt_names->value, &marking.u.fle1.key_alt_name);
             marking.type = MONGOCRYPT_MARKING_FLE1_BY_ALTNAME;
         }
 

src/mongocrypt-marking-private.h

@@ -39,10 +39,10 @@ typedef struct {
 
             _mongocrypt_buffer_t key_id;
             bson_value_t key_alt_name;
-        };
+        } fle1;
 
         mc_FLE2EncryptionPlaceholder_t fle2;
-    };
+    } u;
 } _mongocrypt_marking_t;
 
 // `_mongocrypt_marking_t` inherits extended alignment from libbson. To dynamically allocate, use aligned allocation