Replace most StaticAssertStmt() with StaticAssertDecl()

Similar to commit 75f49221c22, it is preferable to use
StaticAssertDecl() instead of StaticAssertStmt() when possible.

Discussion: https://www.postgresql.org/message-id/flat/CA%2BhUKGKvr0x_oGmQTUkx%3DODgSksT2EtgCA6LmGx_jQFG%3DsDUpg%40mail.gmail.com

diff --git a/contrib/hstore/hstore_compat.c b/contrib/hstore/hstore_compat.c
index d75e9cb23f5cdc4801fe777d0d52c53d16b87c11..3a9f7f45cb71ce9562f9b990de889f567d57f17d 100644 (file)
--- a/contrib/hstore/hstore_compat.c
+++ b/contrib/hstore/hstore_compat.c
@@ -94,7 +94,7 @@
  * etc. are compatible.
  *
  * If the above statement isn't true on some bizarre platform, we're
- * a bit hosed (see StaticAssertStmt in hstoreValidOldFormat).
+ * a bit hosed.
  */
 typedef struct
 {
@@ -105,6 +105,9 @@ typedef struct
                                pos:31;
 } HOldEntry;
 
+StaticAssertDecl(sizeof(HOldEntry) == 2 * sizeof(HEntry),
+                                "old hstore format is not upward-compatible");
+
 static int     hstoreValidNewFormat(HStore *hs);
 static int     hstoreValidOldFormat(HStore *hs);
 
@@ -179,10 +182,6 @@ hstoreValidOldFormat(HStore *hs)
        if (hs->size_ & HS_FLAG_NEWVERSION)
                return 0;
 
-       /* New format uses an HEntry for key and another for value */
-       StaticAssertStmt(sizeof(HOldEntry) == 2 * sizeof(HEntry),
-                                        "old hstore format is not upward-compatible");
-
        if (count == 0)
                return 2;
 

diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c
index e8c99c3773dc2b98692ba676500545d5531e5be7..62035b7f9c3e86f7e1fe8d4f98d3d42995f0388b 100644 (file)
--- a/src/backend/access/heap/vacuumlazy.c
+++ b/src/backend/access/heap/vacuumlazy.c
@@ -3388,6 +3388,9 @@ lazy_truncate_heap(LVRelState *vacrel)
 static BlockNumber
 count_nondeletable_pages(LVRelState *vacrel, bool *lock_waiter_detected)
 {
+       StaticAssertDecl((PREFETCH_SIZE & (PREFETCH_SIZE - 1)) == 0,
+                                        "prefetch size must be power of 2");
+
        BlockNumber blkno;
        BlockNumber prefetchedUntil;
        instr_time      starttime;
@@ -3402,8 +3405,6 @@ count_nondeletable_pages(LVRelState *vacrel, bool *lock_waiter_detected)
         * in forward direction, so that OS-level readahead can kick in.
         */
        blkno = vacrel->rel_pages;
-       StaticAssertStmt((PREFETCH_SIZE & (PREFETCH_SIZE - 1)) == 0,
-                                        "prefetch size must be power of 2");
        prefetchedUntil = InvalidBlockNumber;
        while (blkno > vacrel->nonempty_pages)
        {

diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c
index 1e099febdc8cacf34d60264dbe1c3e60eff895a2..73ebc01a08fb3cf7ec599bc5ea8952b4ccec5d8c 100644 (file)
--- a/src/backend/access/table/tableam.c
+++ b/src/backend/access/table/tableam.c
@@ -462,15 +462,15 @@ table_block_parallelscan_startblock_init(Relation rel,
                                                                                 BlockNumber startblock,
                                                                                 BlockNumber numblocks)
 {
+       StaticAssertDecl(MaxBlockNumber <= 0xFFFFFFFE,
+                                        "pg_nextpower2_32 may be too small for non-standard BlockNumber width");
+
        BlockNumber sync_startpage = InvalidBlockNumber;
        BlockNumber scan_nblocks;
 
        /* Reset the state we use for controlling allocation size. */
        memset(pbscanwork, 0, sizeof(*pbscanwork));
 
-       StaticAssertStmt(MaxBlockNumber <= 0xFFFFFFFE,
-                                        "pg_nextpower2_32 may be too small for non-standard BlockNumber width");
-
 retry:
        /* Grab the spinlock. */
        SpinLockAcquire(&pbscan->phs_mutex);

diff --git a/src/backend/access/transam/parallel.c b/src/backend/access/transam/parallel.c
index 8428103eba41f6cc6b385bfed56d25fee0b9aa65..956b23816dea6beb34f7efd0564eec8f7876fe67 100644 (file)
--- a/src/backend/access/transam/parallel.c
+++ b/src/backend/access/transam/parallel.c
@@ -266,6 +266,10 @@ InitializeParallelDSM(ParallelContext *pcxt)
 
        if (pcxt->nworkers > 0)
        {
+               StaticAssertDecl(BUFFERALIGN(PARALLEL_ERROR_QUEUE_SIZE) ==
+                                                PARALLEL_ERROR_QUEUE_SIZE,
+                                                "parallel error queue size not buffer-aligned");
+
                /* Estimate space for various kinds of state sharing. */
                library_len = EstimateLibraryStateSpace();
                shm_toc_estimate_chunk(&pcxt->estimator, library_len);
@@ -297,9 +301,6 @@ InitializeParallelDSM(ParallelContext *pcxt)
                shm_toc_estimate_keys(&pcxt->estimator, 12);
 
                /* Estimate space need for error queues. */
-               StaticAssertStmt(BUFFERALIGN(PARALLEL_ERROR_QUEUE_SIZE) ==
-                                                PARALLEL_ERROR_QUEUE_SIZE,
-                                                "parallel error queue size not buffer-aligned");
                shm_toc_estimate_chunk(&pcxt->estimator,
                                                           mul_size(PARALLEL_ERROR_QUEUE_SIZE,
                                                                                pcxt->nworkers));

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index e78912cd141aeb785b46c8520f1eada9f517f8ec..c3e72fb1b967dc092934b418e205a7b3c8fd1c5d 100644 (file)
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -7149,9 +7149,9 @@ buffer_readv_encode_error(PgAioResult *result,
                error_count > 0 ? error_count : zeroed_count;
        uint8           first_off;
 
-       StaticAssertStmt(PG_IOV_MAX <= 1 << READV_COUNT_BITS,
+       StaticAssertDecl(PG_IOV_MAX <= 1 << READV_COUNT_BITS,
                                         "PG_IOV_MAX is bigger than reserved space for error data");
-       StaticAssertStmt((1 + 1 + 3 * READV_COUNT_BITS) <= PGAIO_RESULT_ERROR_BITS,
+       StaticAssertDecl((1 + 1 + 3 * READV_COUNT_BITS) <= PGAIO_RESULT_ERROR_BITS,
                                         "PGAIO_RESULT_ERROR_BITS is insufficient for buffer_readv");
 
        /*

diff --git a/src/backend/storage/file/fd.c b/src/backend/storage/file/fd.c
index 716fd7749b65da70b81cf6880d952a1cff615e30..9670e809b724c0fcd19c21aba2fe2c8cad649ceb 100644 (file)
--- a/src/backend/storage/file/fd.c
+++ b/src/backend/storage/file/fd.c
@@ -1111,23 +1111,6 @@ BasicOpenFilePerm(const char *fileName, int fileFlags, mode_t fileMode)
 
 tryAgain:
 #ifdef PG_O_DIRECT_USE_F_NOCACHE
-
-       /*
-        * The value we defined to stand in for O_DIRECT when simulating it with
-        * F_NOCACHE had better not collide with any of the standard flags.
-        */
-       StaticAssertStmt((PG_O_DIRECT &
-                                         (O_APPEND |
-                                          O_CLOEXEC |
-                                          O_CREAT |
-                                          O_DSYNC |
-                                          O_EXCL |
-                                          O_RDWR |
-                                          O_RDONLY |
-                                          O_SYNC |
-                                          O_TRUNC |
-                                          O_WRONLY)) == 0,
-                                        "PG_O_DIRECT value collides with standard flag");
        fd = open(fileName, fileFlags & ~PG_O_DIRECT, fileMode);
 #else
        fd = open(fileName, fileFlags, fileMode);

diff --git a/src/backend/storage/ipc/waiteventset.c b/src/backend/storage/ipc/waiteventset.c
index b5431ad3c5c3d71b76d886ee88fd8c860a87c240..f2174e72ae68e389951d328ca0ec36034cfcc234 100644 (file)
--- a/src/backend/storage/ipc/waiteventset.c
+++ b/src/backend/storage/ipc/waiteventset.c
@@ -462,7 +462,6 @@ CreateWaitEventSet(ResourceOwner resowner, int nevents)
         * pending signals are serviced.
         */
        set->handles[0] = pgwin32_signal_event;
-       StaticAssertStmt(WSA_INVALID_EVENT == NULL, "");
 #endif
 
        return set;
@@ -979,6 +978,8 @@ WaitEventAdjustKqueue(WaitEventSet *set, WaitEvent *event, int old_events)
 #endif
 
 #if defined(WAIT_USE_WIN32)
+StaticAssertDecl(WSA_INVALID_EVENT == NULL, "");
+
 static void
 WaitEventAdjustWin32(WaitEventSet *set, WaitEvent *event)
 {

diff --git a/src/backend/utils/adt/mac.c b/src/backend/utils/adt/mac.c
index 35234e700ffe64a748424c9d8d9a9f4c449d11d7..bb12ed758cb1108cd1f78e51e77da539cdeffc75 100644 (file)
--- a/src/backend/utils/adt/mac.c
+++ b/src/backend/utils/adt/mac.c
@@ -485,7 +485,7 @@ macaddr_abbrev_convert(Datum original, SortSupport ssup)
         * There will be two bytes of zero padding on the end of the least
         * significant bits.
         */
-       StaticAssertStmt(sizeof(res) >= sizeof(macaddr),
+       StaticAssertDecl(sizeof(res) >= sizeof(macaddr),
                                         "Datum is too small for macaddr");
        memset(&res, 0, sizeof(res));
        memcpy(&res, authoritative, sizeof(macaddr));

diff --git a/src/backend/utils/cache/inval.c b/src/backend/utils/cache/inval.c
index 868f8f6188f7001e82a3ef7977382266a0e77103..9d16ca10ae129e51993950995a3342f28fac83d7 100644 (file)
--- a/src/backend/utils/cache/inval.c
+++ b/src/backend/utils/cache/inval.c
@@ -1753,7 +1753,7 @@ CacheInvalidateSmgr(RelFileLocatorBackend rlocator)
        SharedInvalidationMessage msg;
 
        /* verify optimization stated above stays valid */
-       StaticAssertStmt(MAX_BACKENDS_BITS <= 23,
+       StaticAssertDecl(MAX_BACKENDS_BITS <= 23,
                                         "MAX_BACKENDS_BITS is too big for inval.c");
 
        msg.sm.id = SHAREDINVALSMGR_ID;

diff --git a/src/include/storage/fd.h b/src/include/storage/fd.h
index a1bdefec4a59b318a13d189b74fc426b9fa72b8e..a8b0c9b3997ef284ec689bbda785ec468bbae707 100644 (file)
--- a/src/include/storage/fd.h
+++ b/src/include/storage/fd.h
@@ -92,6 +92,22 @@ extern PGDLLIMPORT int max_safe_fds;
 #elif defined(F_NOCACHE)
 #define                PG_O_DIRECT 0x80000000
 #define                PG_O_DIRECT_USE_F_NOCACHE
+/*
+ * The value we defined to stand in for O_DIRECT when simulating it with
+ * F_NOCACHE had better not collide with any of the standard flags.
+ */
+StaticAssertDecl((PG_O_DIRECT &
+                                 (O_APPEND |
+                                  O_CLOEXEC |
+                                  O_CREAT |
+                                  O_DSYNC |
+                                  O_EXCL |
+                                  O_RDWR |
+                                  O_RDONLY |
+                                  O_SYNC |
+                                  O_TRUNC |
+                                  O_WRONLY)) == 0,
+                                "PG_O_DIRECT value collides with standard flag");
 #else
 #define                PG_O_DIRECT 0
 #endif