Why does gcc need the definition of unused _Generic values?

Consider this code:

#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
//#include <float.h> //uncomment so it can be compiled

#define GETMAX(variable) _Generic        \
  (                                      \
    (variable)                           \
    , bool                : 1            \
    , char                : CHAR_MAX     \
    , unsigned char       : UCHAR_MAX    \
    , signed   char       : SCHAR_MAX    \
    , unsigned short      : USHRT_MAX    \
    , signed   short      : SHRT_MAX     \
    , unsigned int        : UINT_MAX     \
    , signed   int        : INT_MAX      \
    , unsigned long       : ULONG_MAX    \
    , signed   long       : LONG_MAX     \
    , unsigned long long  : ULLONG_MAX   \
    , signed   long long  : LLONG_MAX    \
    , float               : FLT_MAX      \
    , double              : DBL_MAX      \
    , long double         : LDBL_MAX     \
  )

int main(int argc, char **argv)
{
  (void)argv;
  uint_fast8_t a;
  if( argc>GETMAX(a) )
    { printf("argc too big\n"); }
  else
    { printf("argc small enough\n"); }
  return 0;
}

It will not compile with gcc nor clang (don't know about other compilers), gcc complains with error: ‘FLT_MAX’ undeclared (first use in this function) ... (even without any warning flags) But why? i use the GETMAX with a integer, the value of FLT_MAX is irrelevant for that, on my machine, only UCHAR_MAX should be needed. The line if( argc>GETMAX(a) ) should turn into a equivalent of if( argc>UCHAR_MAX ) (after compiling, FLT_MAX is still there after the preprocessor), making all other limits irrelevant.

The fix is easy, just add #include <float.h>, the question is about why this is the way it is.

C expects all identifiers used in expressions to be declared.¹ While it might be possible to redesign the language to ignore undeclared identifiers in certain places, requiring declarations helps avoid bugs.

There are other places where an unknown identifier might be ignored. For example, consider:

int foo(void)
{
	return 1 || x;
}

The value of 1 || x is 1 regardless of what value x has. However, if typedef int x; were in the code before this, it would be an error, because the right operand of || must be a grammatical logical-AND-expression, and a type is not an expression. So, with x undeclared, the compiler cannot check whether 1 || x is a valid expression as defined by the rules of the C standard.

Another example is int a[3]; return sizeof a[x];, which would, if accepted, return the size of an int regardless of x. In this, the C standard says x is not evaluated. Yet it must be declared. Another example is return 0; x;. Here, there is no way for program control to reach x, so it is never evaluated. Yet it must be declared.

Similarly, in _Generic, the grammatical entity after a : must be an assignment-expression, and the compiler cannot check that unless the identifiers in it are declared.

Footnote

¹ In the past, an identifier used as a function designator in a call would be automatically assumed to be a function. This has been removed from the C standard.