How does a C compiler parse code like `arr[]`?

It is well known that function declarations like

void foo (int arr[])

and

void foo (int* arr)

are identical since array variables are just pointers to the first element of the array.

My question is about how a C compiler processes the first version. Does it work just like other compiler directives (#define) and simply substitute for the second?

… array variables are just pointers to the first element of the array.

They are not. There are contexts in which an array is converted to a pointer to its first element, but an array is not just a pointer to its first element, and it cannot be because there are contexts in which an array is not converted to a pointer to its first element. The compiler must distinguish between an array and a pointer until sufficient context is resolved.

For purposes of specifying C semantics, in declarations of function parameters, a declaration of an array is automatically adjusted to be an declaration of a pointer. However, that adjustment is a conceptual act. It does not have to be implemented in a particular way in a compiler. It can be implemented in various ways, or the necessary semantics can be provided without any actual adjustment.

For example, when a parameter is declared to be a pointer, the compiler has to do certain things such as:

• When the function is called, the compiler must check the rules applicable to passing an argument for a pointer parameter and may need to convert the argument to the parameter type.
• In the function definition, the compiler must process references to the parameter as references to a pointer object.

Now, when a parameter is declared to be an array, the compiler can implement the semantics required by the C standard by fully processing the declaration and constructing its own internal representation of the declared identifier and then adjusting that internal representation to represent a pointer type. However, another way for the compiler to implement the semantics is to keep the internal representation unchanged but process it using the same rules it would for a pointer parameter:

• When the function is called, check the rules applicable to passing an argument for a pointer parameter and, if applicable, convert the argument to the pointer type corresponding to the declared array type.
• In the function definition, the compiler process references to the parameter as references to a pointer object.

So, there are multiple ways a compiler can implement the behavior required by the C standard.