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