Проверьте, является ли массив VLA во время компиляции

@Lundin показывает, как проверить, является ли переданное выражение массивом во время компиляции: Неверное преобразование Lvalue управляющего выражения _Generic с предупреждением о звоне массива?:

#define IS_ARRAY(T)            \
  _Generic( &(T),              \
    typeof(*T) (*)[]  : true,  \
    default           : false  \
  )

Можем ли мы дополнительно отличить массив, который имеет тип массива переменной длины, от массива, который его не имеет?

Зачем мне это нужно? У меня есть универсальный вариант SWAP(), который не работает для VLA. Я хотел бы проверить во время компиляции (static_assert), был ли передан VLA в SWAP(), и посоветовать пользователю использовать другой вариант SWAP(), который работает для VLA. Это было бы более понятно, чем ошибка компилятора, связанная с наличием массива переменной длины в составном литерале...

Для любопытных вот код:

```c
#include <string.h>

/**
 * Like C11's _Static_assert() except that it can be used in an expression.
 *
 * EXPR - The expression to check.
 * MSG  - The string literal of the error message to print only if EXPR evalutes
 *        to false.
 *
 * Always return 1 (true). */
#define STATIC_ASSERT_EXPR(EXPR, MSG)   \
    (!!sizeof( struct { static_assert ( (EXPR), MSG ); char c; } ))

/**
 * Determines if an expression is compatible with a type.
 *
 * Expands to 1 (true) if X is compatible with T, else 0 (false). */
#define IS_COMPATIBLE(X, T) \
    _Generic((X),           \
            T:       1,     \
            default: 0)     

[[gnu::always_inline]] static inline void swap_internal(size_t psize,
                                                        void *restrict tmp, 
                                                        void *restrict p1, 
                                                        void *restrict p2)
{
    memcpy(tmp, p1, psize);
    memcpy(p1, p2, psize);
    memcpy(p2, tmp, psize);
}

/**
 * Swaps the contents of A and B.
 *
 * Properties:
 *  - It evaluates each of A and B only once.
 *  - It has a compile-time check for the correct sizes, and prints a nice,
 *    user-friendly error message if the sizes are different.
 *  - It has a compile-time check for compatible types, and prints a nice, 
 *    user-friendly error message if the types are incompatible.
 *  - It has no naming issue with a hidden variable.
 *  - The size of the temporary variable is computed at compile time, so the 
 *    compound literal is not a dynamic array.
 *  - It does not rely on VLAs, so it is more portable.
 *
 * Note: The expressions must allow the & operator to be applicable. Thus it 
 * will not work on variables that are declared with the register storage class.
 * Moreover, it would also not work with VLAs, and would invoke undefined
 * behavior if A and B are the same. */
#define SWAP(A, B)                                                          \
    swap_internal(                                                          \
        (sizeof (A) * STATIC_ASSERT_EXPR( sizeof (A) == sizeof (B),         \
            #A " and " #B " must have same size.")),                        \
        (char [ STATIC_ASSERT_EXPR( IS_COMPATIBLE(A, typeof(B)),            \
            #A " and " #B " must have compatible types") * sizeof (A)] {}), \
        &(A),                                                               \
        &(B))