Why does a C macro invocation eat up curly braces?

Question

Consider:

#define TEST(x) x
int arr[2] = TEST({1, 2});

I would expect it to be preprocessed into int arr[2] = {1, 2};

Instead, both gcc and clang complain. gcc 7.3.0:

./test.c:2:25: error: macro "TEST" passed 2 arguments, but takes just 1
 int arr[2] = TEST({1, 2});

clang 3.8.1:

./test.c:2:23: error: too many arguments provided to function-like macro invocation
int arr[2] = TEST({1, 2});

I couldn't find any mention of curly braces being treated specially in the C language standard section on macros (6.10).

Why does this happen?

Answer 1

The reason is that the invocation is split by comma to find the arguments, ignoring any characters such as { and } (see below for quote from the standard). Only regular parens are treated specially.

So TEST({1, 2}) is interpreted as being passed two arguments, {1 and 2}. Indeed:

#define TEST(x, y) | x | y |
int arr[2] = TEST({1, 2});

Is preprocessed into:

int arr[2] = | {1 | 2} |;

Section 6.10.3.11:

The sequence of preprocessing tokens bounded by the outside-most matching parentheses forms the list of arguments for the function-like macro. The individual arguments within the list are separated by comma preprocessing tokens, but comma preprocessing tokens between matching inner parentheses do not separate arguments. If there are sequences of preprocessing tokens within the list of arguments that would otherwise act as preprocessing directives, 172) the behavior is undefined.